• Skip to content
  • Skip to link menu
KDE API Reference
  • KDE API Reference
  • graphics API Reference
  • KDE Home
  • Contact Us
 

digikam

  • extragear
  • graphics
  • digikam
  • core
  • libs
  • dngwriter
  • extra
  • dng_sdk
dng_utils.h
Go to the documentation of this file.
1 /*****************************************************************************/
2 // Copyright 2006-2008 Adobe Systems Incorporated
3 // All Rights Reserved.
4 //
5 // NOTICE: Adobe permits you to use, modify, and distribute this file in
6 // accordance with the terms of the Adobe license agreement accompanying it.
7 /*****************************************************************************/
8 
9 /* $Id: //mondo/dng_sdk_1_3/dng_sdk/source/dng_utils.h#1 $ */
10 /* $DateTime: 2009/06/22 05:04:49 $ */
11 /* $Change: 578634 $ */
12 /* $Author: tknoll $ */
13 
14 /*****************************************************************************/
15 
16 #ifndef __dng_utils__
17 #define __dng_utils__
18 
19 /*****************************************************************************/
20 
21 #include "dng_classes.h"
22 #include "dng_flags.h"
23 #include "dng_types.h"
24 
25 /*****************************************************************************/
26 
27 inline uint32 Abs_int32 (int32 x)
28  {
29 
30  #if 0
31 
32  // Reference version.
33 
34  return (uint32) (x < 0 ? -x : x);
35 
36  #else
37 
38  // Branchless version.
39 
40  uint32 mask = x >> 31;
41 
42  return (uint32) ((x + mask) ^ mask);
43 
44  #endif
45 
46  }
47 
48 inline int32 Min_int32 (int32 x, int32 y)
49  {
50 
51  return (x <= y ? x : y);
52 
53  }
54 
55 inline int32 Max_int32 (int32 x, int32 y)
56  {
57 
58  return (x >= y ? x : y);
59 
60  }
61 
62 inline int32 Pin_int32 (int32 min, int32 x, int32 max)
63  {
64 
65  return Max_int32 (min, Min_int32 (x, max));
66 
67  }
68 
69 inline int32 Pin_int32_between (int32 a, int32 x, int32 b)
70  {
71 
72  int32 min, max;
73  if (a < b) { min = a; max = b; }
74  else { min = b; max = a; }
75 
76  return Pin_int32 (min, x, max);
77 
78  }
79 
80 /*****************************************************************************/
81 
82 inline uint16 Min_uint16 (uint16 x, uint16 y)
83  {
84 
85  return (x <= y ? x : y);
86 
87  }
88 
89 inline uint16 Max_uint16 (uint16 x, uint16 y)
90  {
91 
92  return (x >= y ? x : y);
93 
94  }
95 
96 inline int16 Pin_int16 (int32 x)
97  {
98 
99  x = Pin_int32 (-32768, x, 32767);
100 
101  return (int16) x;
102 
103  }
104 
105 /*****************************************************************************/
106 
107 inline uint32 Min_uint32 (uint32 x, uint32 y)
108  {
109 
110  return (x <= y ? x : y);
111 
112  }
113 
114 inline uint32 Min_uint32 (uint32 x, uint32 y, uint32 z)
115  {
116 
117  return Min_uint32 (x, Min_uint32 (y, z));
118 
119  }
120 
121 inline uint32 Max_uint32 (uint32 x, uint32 y)
122  {
123 
124  return (x >= y ? x : y);
125 
126  }
127 
128 inline uint32 Max_uint32 (uint32 x, uint32 y, uint32 z)
129  {
130 
131  return Max_uint32 (x, Max_uint32 (y, z));
132 
133  }
134 
135 inline uint32 Pin_uint32 (uint32 min, uint32 x, uint32 max)
136  {
137 
138  return Max_uint32 (min, Min_uint32 (x, max));
139 
140  }
141 
142 /*****************************************************************************/
143 
144 inline uint16 Pin_uint16 (int32 x)
145  {
146 
147  #if 0
148 
149  // Reference version.
150 
151  x = Pin_int32 (0, x, 0x0FFFF);
152 
153  #else
154 
155  // Single branch version.
156 
157  if (x & ~65535)
158  {
159 
160  x = ~x >> 31;
161 
162  }
163 
164  #endif
165 
166  return (uint16) x;
167 
168  }
169 
170 /*****************************************************************************/
171 
172 inline uint32 RoundUp2 (uint32 x)
173  {
174 
175  return (x + 1) & ~1;
176 
177  }
178 
179 inline uint32 RoundUp4 (uint32 x)
180  {
181 
182  return (x + 3) & ~3;
183 
184  }
185 
186 inline uint32 RoundUp8 (uint32 x)
187  {
188 
189  return (x + 7) & ~7;
190 
191  }
192 
193 inline uint32 RoundUp16 (uint32 x)
194  {
195 
196  return (x + 15) & ~15;
197 
198  }
199 
200 inline uint32 RoundUp4096 (uint32 x)
201  {
202 
203  return (x + 4095) & ~4095;
204 
205  }
206 
207 /******************************************************************************/
208 
209 inline uint32 RoundDown2 (uint32 x)
210  {
211 
212  return x & ~1;
213 
214  }
215 
216 inline uint32 RoundDown4 (uint32 x)
217  {
218 
219  return x & ~3;
220 
221  }
222 
223 inline uint32 RoundDown8 (uint32 x)
224  {
225 
226  return x & ~7;
227 
228  }
229 
230 inline uint32 RoundDown16 (uint32 x)
231  {
232 
233  return x & ~15;
234 
235  }
236 
237 /******************************************************************************/
238 
239 inline uint32 RoundUpForPixelSize (uint32 x, uint32 pixelSize)
240  {
241 
242  switch (pixelSize)
243  {
244 
245  case 1:
246  return RoundUp16 (x);
247 
248  case 2:
249  return RoundUp8 (x);
250 
251  case 4:
252  return RoundUp4 (x);
253 
254  case 8:
255  return RoundUp2 (x);
256 
257  default:
258  return RoundUp16 (x);
259 
260  }
261 
262  }
263 
264 /******************************************************************************/
265 
266 inline uint64 Abs_int64 (int64 x)
267  {
268 
269  return (uint64) (x < 0 ? -x : x);
270 
271  }
272 
273 inline int64 Min_int64 (int64 x, int64 y)
274  {
275 
276  return (x <= y ? x : y);
277 
278  }
279 
280 inline int64 Max_int64 (int64 x, int64 y)
281  {
282 
283  return (x >= y ? x : y);
284 
285  }
286 
287 inline int64 Pin_int64 (int64 min, int64 x, int64 max)
288  {
289 
290  return Max_int64 (min, Min_int64 (x, max));
291 
292  }
293 
294 /******************************************************************************/
295 
296 inline uint64 Min_uint64 (uint64 x, uint64 y)
297  {
298 
299  return (x <= y ? x : y);
300 
301  }
302 
303 inline uint64 Max_uint64 (uint64 x, uint64 y)
304  {
305 
306  return (x >= y ? x : y);
307 
308  }
309 
310 inline uint64 Pin_uint64 (uint64 min, uint64 x, uint64 max)
311  {
312 
313  return Max_uint64 (min, Min_uint64 (x, max));
314 
315  }
316 
317 /*****************************************************************************/
318 
319 inline real32 Abs_real32 (real32 x)
320  {
321 
322  return (x < 0.0f ? -x : x);
323 
324  }
325 
326 inline real32 Min_real32 (real32 x, real32 y)
327  {
328 
329  return (x < y ? x : y);
330 
331  }
332 
333 inline real32 Max_real32 (real32 x, real32 y)
334  {
335 
336  return (x > y ? x : y);
337 
338  }
339 
340 inline real32 Pin_real32 (real32 min, real32 x, real32 max)
341  {
342 
343  return Max_real32 (min, Min_real32 (x, max));
344 
345  }
346 
347 inline real32 Pin_real32 (real32 x)
348  {
349 
350  return Pin_real32 (0.0f, x, 1.0f);
351 
352  }
353 
354 inline real32 Lerp_real32 (real32 a, real32 b, real32 t)
355  {
356 
357  return a + t * (b - a);
358 
359  }
360 
361 /*****************************************************************************/
362 
363 inline real64 Abs_real64 (real64 x)
364  {
365 
366  return (x < 0.0 ? -x : x);
367 
368  }
369 
370 inline real64 Min_real64 (real64 x, real64 y)
371  {
372 
373  return (x < y ? x : y);
374 
375  }
376 
377 inline real64 Max_real64 (real64 x, real64 y)
378  {
379 
380  return (x > y ? x : y);
381 
382  }
383 
384 inline real64 Pin_real64 (real64 min, real64 x, real64 max)
385  {
386 
387  return Max_real64 (min, Min_real64 (x, max));
388 
389  }
390 
391 inline real64 Pin_real64 (real64 x)
392  {
393 
394  return Pin_real64 (0.0, x, 1.0);
395 
396  }
397 
398 inline real64 Lerp_real64 (real64 a, real64 b, real64 t)
399  {
400 
401  return a + t * (b - a);
402 
403  }
404 
405 /*****************************************************************************/
406 
407 inline int32 Round_int32 (real32 x)
408  {
409 
410  return (int32) (x > 0.0f ? x + 0.5f : x - 0.5f);
411 
412  }
413 
414 inline int32 Round_int32 (real64 x)
415  {
416 
417  return (int32) (x > 0.0 ? x + 0.5 : x - 0.5);
418 
419  }
420 
421 inline uint32 Floor_uint32 (real32 x)
422  {
423 
424  return (uint32) Max_real32 (0.0f, x);
425 
426  }
427 
428 inline uint32 Floor_uint32 (real64 x)
429  {
430 
431  return (uint32) Max_real64 (0.0, x);
432 
433  }
434 
435 inline uint32 Round_uint32 (real32 x)
436  {
437 
438  return Floor_uint32 (x + 0.5f);
439 
440  }
441 
442 inline uint32 Round_uint32 (real64 x)
443  {
444 
445  return Floor_uint32 (x + 0.5);
446 
447  }
448 
449 /******************************************************************************/
450 
451 inline int64 Round_int64 (real64 x)
452  {
453 
454  return (int64) (x >= 0.0 ? x + 0.5 : x - 0.5);
455 
456  }
457 
458 /*****************************************************************************/
459 
460 const int64 kFixed64_One = (((int64) 1) << 32);
461 const int64 kFixed64_Half = (((int64) 1) << 31);
462 
463 /******************************************************************************/
464 
465 inline int64 Real64ToFixed64 (real64 x)
466  {
467 
468  return Round_int64 (x * (real64) kFixed64_One);
469 
470  }
471 
472 /******************************************************************************/
473 
474 inline real64 Fixed64ToReal64 (int64 x)
475  {
476 
477  return x * (1.0 / (real64) kFixed64_One);
478 
479  }
480 
481 /*****************************************************************************/
482 
483 inline char ForceUppercase (char c)
484  {
485 
486  if (c >= 'a' && c <= 'z')
487  {
488 
489  c -= 'a' - 'A';
490 
491  }
492 
493  return c;
494 
495  }
496 
497 /*****************************************************************************/
498 
499 inline uint16 SwapBytes16 (uint16 x)
500  {
501 
502  return (x << 8) |
503  (x >> 8);
504 
505  }
506 
507 inline uint32 SwapBytes32 (uint32 x)
508  {
509 
510  return (x << 24) +
511  ((x << 8) & 0x00FF0000) +
512  ((x >> 8) & 0x0000FF00) +
513  (x >> 24);
514 
515  }
516 
517 /*****************************************************************************/
518 
519 inline bool IsAligned16 (const void *p)
520  {
521 
522  return (((uintptr) p) & 1) == 0;
523 
524  }
525 
526 inline bool IsAligned32 (const void *p)
527  {
528 
529  return (((uintptr) p) & 3) == 0;
530 
531  }
532 
533 inline bool IsAligned64 (const void *p)
534  {
535 
536  return (((uintptr) p) & 7) == 0;
537 
538  }
539 
540 inline bool IsAligned128 (const void *p)
541  {
542 
543  return (((uintptr) p) & 15) == 0;
544 
545  }
546 
547 /******************************************************************************/
548 
549 // Converts from RGB values (range 0.0 to 1.0) to HSV values (range 0.0 to
550 // 6.0 for hue, and 0.0 to 1.0 for saturation and value).
551 
552 inline void DNG_RGBtoHSV (real32 r,
553  real32 g,
554  real32 b,
555  real32 &h,
556  real32 &s,
557  real32 &v)
558  {
559 
560  v = Max_real32 (r, Max_real32 (g, b));
561 
562  real32 gap = v - Min_real32 (r, Min_real32 (g, b));
563 
564  if (gap > 0.0f)
565  {
566 
567  if (r == v)
568  {
569 
570  h = (g - b) / gap;
571 
572  if (h < 0.0f)
573  {
574  h += 6.0f;
575  }
576 
577  }
578 
579  else if (g == v)
580  {
581  h = 2.0f + (b - r) / gap;
582  }
583 
584  else
585  {
586  h = 4.0f + (r - g) / gap;
587  }
588 
589  s = gap / v;
590 
591  }
592 
593  else
594  {
595  h = 0.0f;
596  s = 0.0f;
597  }
598 
599  }
600 
601 /*****************************************************************************/
602 
603 // Converts from HSV values (range 0.0 to 6.0 for hue, and 0.0 to 1.0 for
604 // saturation and value) to RGB values (range 0.0 to 1.0).
605 
606 inline void DNG_HSVtoRGB (real32 h,
607  real32 s,
608  real32 v,
609  real32 &r,
610  real32 &g,
611  real32 &b)
612  {
613 
614  if (s > 0.0f)
615  {
616 
617  if (h < 0.0f)
618  h += 6.0f;
619 
620  if (h >= 6.0f)
621  h -= 6.0f;
622 
623  int32 i = (int32) h;
624  real32 f = h - (real32) i;
625 
626  real32 p = v * (1.0f - s);
627 
628  #define q (v * (1.0f - s * f))
629  #define t (v * (1.0f - s * (1.0f - f)))
630 
631  switch (i)
632  {
633  case 0: r = v; g = t; b = p; break;
634  case 1: r = q; g = v; b = p; break;
635  case 2: r = p; g = v; b = t; break;
636  case 3: r = p; g = q; b = v; break;
637  case 4: r = t; g = p; b = v; break;
638  case 5: r = v; g = p; b = q; break;
639  }
640 
641  #undef q
642  #undef t
643 
644  }
645 
646  else
647  {
648  r = v;
649  g = v;
650  b = v;
651  }
652 
653  }
654 
655 /******************************************************************************/
656 
657 // High resolution timer, for code profiling.
658 
659 real64 TickTimeInSeconds ();
660 
661 // Lower resolution timer, but more stable.
662 
663 real64 TickCountInSeconds ();
664 
665 /******************************************************************************/
666 
667 class dng_timer
668  {
669 
670  public:
671 
672  dng_timer (const char *message);
673 
674  ~dng_timer ();
675 
676  private:
677 
678  // Hidden copy constructor and assignment operator.
679 
680  dng_timer (const dng_timer &timer);
681 
682  dng_timer & operator= (const dng_timer &timer);
683 
684  private:
685 
686  const char *fMessage;
687 
688  real64 fStartTime;
689 
690  };
691 
692 /*****************************************************************************/
693 
694 // Returns the maximum squared Euclidean distance from the specified point to the
695 // specified rectangle rect.
696 
697 real64 MaxSquaredDistancePointToRect (const dng_point_real64 &point,
698  const dng_rect_real64 &rect);
699 
700 /*****************************************************************************/
701 
702 // Returns the maximum Euclidean distance from the specified point to the specified
703 // rectangle rect.
704 
705 real64 MaxDistancePointToRect (const dng_point_real64 &point,
706  const dng_rect_real64 &rect);
707 
708 /*****************************************************************************/
709 
710 #endif
711 
712 /*****************************************************************************/
dng_flags.h
Conditional compilation flags for DNG SDK.
Fixed64ToReal64
real64 Fixed64ToReal64(int64 x)
Definition: dng_utils.h:474
IsAligned64
bool IsAligned64(const void *p)
Definition: dng_utils.h:533
RoundUp4
uint32 RoundUp4(uint32 x)
Definition: dng_utils.h:179
RoundDown4
uint32 RoundDown4(uint32 x)
Definition: dng_utils.h:216
uintptr
uintptr_t uintptr
Definition: dng_types.h:69
IsAligned32
bool IsAligned32(const void *p)
Definition: dng_utils.h:526
SwapBytes32
uint32 SwapBytes32(uint32 x)
Definition: dng_utils.h:507
Max_uint16
uint16 Max_uint16(uint16 x, uint16 y)
Definition: dng_utils.h:89
Lerp_real64
real64 Lerp_real64(real64 a, real64 b, real64 t)
Definition: dng_utils.h:398
Lerp_real32
real32 Lerp_real32(real32 a, real32 b, real32 t)
Definition: dng_utils.h:354
uint64
unsigned long long uint64
Definition: dng_types.h:65
IsAligned16
bool IsAligned16(const void *p)
Definition: dng_utils.h:519
Pin_uint32
uint32 Pin_uint32(uint32 min, uint32 x, uint32 max)
Definition: dng_utils.h:135
Max_int32
int32 Max_int32(int32 x, int32 y)
Definition: dng_utils.h:55
Min_real32
real32 Min_real32(real32 x, real32 y)
Definition: dng_utils.h:326
RoundDown8
uint32 RoundDown8(uint32 x)
Definition: dng_utils.h:223
dng_timer::dng_timer
dng_timer(const char *message)
Definition: dng_utils.cpp:163
dng_types.h
int32
signed long int32
Definition: dng_types.h:54
Real64ToFixed64
int64 Real64ToFixed64(real64 x)
Definition: dng_utils.h:465
RoundDown16
uint32 RoundDown16(uint32 x)
Definition: dng_utils.h:230
RoundUp2
uint32 RoundUp2(uint32 x)
Definition: dng_utils.h:172
t
#define t
RoundUp16
uint32 RoundUp16(uint32 x)
Definition: dng_utils.h:193
IsAligned128
bool IsAligned128(const void *p)
Definition: dng_utils.h:540
Pin_uint64
uint64 Pin_uint64(uint64 min, uint64 x, uint64 max)
Definition: dng_utils.h:310
SwapBytes16
uint16 SwapBytes16(uint16 x)
Definition: dng_utils.h:499
RoundUp8
uint32 RoundUp8(uint32 x)
Definition: dng_utils.h:186
DNG_HSVtoRGB
void DNG_HSVtoRGB(real32 h, real32 s, real32 v, real32 &r, real32 &g, real32 &b)
Definition: dng_utils.h:606
dng_timer
Definition: dng_utils.h:667
int16
signed short int16
Definition: dng_types.h:50
real64
double real64
Definition: dng_types.h:74
int64
signed long long int64
Definition: dng_types.h:56
Min_real64
real64 Min_real64(real64 x, real64 y)
Definition: dng_utils.h:370
kFixed64_One
const int64 kFixed64_One
Definition: dng_utils.h:460
dng_rect_real64
Definition: dng_rect.h:145
Min_int64
int64 Min_int64(int64 x, int64 y)
Definition: dng_utils.h:273
Min_uint64
uint64 Min_uint64(uint64 x, uint64 y)
Definition: dng_utils.h:296
Max_int64
int64 Max_int64(int64 x, int64 y)
Definition: dng_utils.h:280
Pin_int32
int32 Pin_int32(int32 min, int32 x, int32 max)
Definition: dng_utils.h:62
Round_uint32
uint32 Round_uint32(real32 x)
Definition: dng_utils.h:435
kFixed64_Half
const int64 kFixed64_Half
Definition: dng_utils.h:461
Round_int64
int64 Round_int64(real64 x)
Definition: dng_utils.h:451
TickTimeInSeconds
real64 TickTimeInSeconds()
Definition: dng_utils.cpp:104
RoundDown2
uint32 RoundDown2(uint32 x)
Definition: dng_utils.h:209
Max_real64
real64 Max_real64(real64 x, real64 y)
Definition: dng_utils.h:377
dng_point_real64
Definition: dng_point.h:63
Pin_int64
int64 Pin_int64(int64 min, int64 x, int64 max)
Definition: dng_utils.h:287
DNG_RGBtoHSV
void DNG_RGBtoHSV(real32 r, real32 g, real32 b, real32 &h, real32 &s, real32 &v)
Definition: dng_utils.h:552
Pin_real64
real64 Pin_real64(real64 min, real64 x, real64 max)
Definition: dng_utils.h:384
Min_uint32
uint32 Min_uint32(uint32 x, uint32 y)
Definition: dng_utils.h:107
Abs_int32
uint32 Abs_int32(int32 x)
Definition: dng_utils.h:27
Abs_real64
real64 Abs_real64(real64 x)
Definition: dng_utils.h:363
Abs_int64
uint64 Abs_int64(int64 x)
Definition: dng_utils.h:266
RoundUp4096
uint32 RoundUp4096(uint32 x)
Definition: dng_utils.h:200
real32
float real32
Definition: dng_types.h:73
p
#define p
Max_real32
real32 Max_real32(real32 x, real32 y)
Definition: dng_utils.h:333
RoundUpForPixelSize
uint32 RoundUpForPixelSize(uint32 x, uint32 pixelSize)
Definition: dng_utils.h:239
uint16
unsigned short uint16
Definition: dng_types.h:59
dng_timer::~dng_timer
~dng_timer()
Definition: dng_utils.cpp:174
MaxDistancePointToRect
real64 MaxDistancePointToRect(const dng_point_real64 &point, const dng_rect_real64 &rect)
Definition: dng_utils.cpp:210
Max_uint32
uint32 Max_uint32(uint32 x, uint32 y)
Definition: dng_utils.h:121
Round_int32
int32 Round_int32(real32 x)
Definition: dng_utils.h:407
max
#define max(a, b)
Find the maximum of 2 numbers.
Definition: bigint_impl.h:125
Min_int32
int32 Min_int32(int32 x, int32 y)
Definition: dng_utils.h:48
Min_uint16
uint16 Min_uint16(uint16 x, uint16 y)
Definition: dng_utils.h:82
Pin_uint16
uint16 Pin_uint16(int32 x)
Definition: dng_utils.h:144
MaxSquaredDistancePointToRect
real64 MaxSquaredDistancePointToRect(const dng_point_real64 &point, const dng_rect_real64 &rect)
Definition: dng_utils.cpp:185
dng_classes.h
Floor_uint32
uint32 Floor_uint32(real32 x)
Definition: dng_utils.h:421
Abs_real32
real32 Abs_real32(real32 x)
Definition: dng_utils.h:319
TickCountInSeconds
real64 TickCountInSeconds()
Definition: dng_utils.cpp:142
Pin_real32
real32 Pin_real32(real32 min, real32 x, real32 max)
Definition: dng_utils.h:340
uint32
unsigned long uint32
Definition: dng_types.h:63
ForceUppercase
char ForceUppercase(char c)
Definition: dng_utils.h:483
min
#define min(a, b)
Find the minimum of 2 numbers.
Definition: bigint_impl.h:126
Pin_int16
int16 Pin_int16(int32 x)
Definition: dng_utils.h:96
Max_uint64
uint64 Max_uint64(uint64 x, uint64 y)
Definition: dng_utils.h:303
q
#define q
Pin_int32_between
int32 Pin_int32_between(int32 a, int32 x, int32 b)
Definition: dng_utils.h:69
mask
#define mask
Definition: var_defines.h:56
b
long b
Definition: 62/jpegint.h:371
This file is part of the KDE documentation.
Documentation copyright © 1996-2019 The KDE developers.
Generated on Thu Dec 12 2019 03:09:47 by doxygen 1.8.7 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.

digikam

Skip menu "digikam"
  • Main Page
  • Namespace List
  • Namespace Members
  • Alphabetical List
  • Class List
  • Class Hierarchy
  • Class Members
  • File List
  • File Members
  • Modules
  • Related Pages
-->

graphics API Reference

Skip menu "graphics API Reference"
  • digikam
  • KDiagram
  •     KChart
  •     KGantt
  • KPhotoAlbum
  •   AndroidRemoteControl
  • Krita
  •   libs
  •     KritaBasicFlakes
  •     brush
  •     KritaUndo2
  •     KritaFlake
  •     image
  •     KritaPlugin
  •     Krita
  •     KritaOdf
  •     KritaPigment
  •     KritaStore
  •     ui
  •     KritaWidgets
  •     KritaWidgetUtils
  •   plugins
  •     Assitants
  •     Extensions
  •     Filters
  •         KritaText
  •         KritaTextLayout
  •     Generators
  •     Formats
  •             src
  •     PaintOps
  •       libpaintop
Report problems with this website to our bug tracking system.
Contact the specific authors with questions and comments about the page contents.

KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal