?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
First import
[xorg_rtime.git] / xorg-server-1.4 / randr / rrproperty.c
blob5ac073f812799d8bd6f547bd26fff01a96750d83
1 /*
2 * Copyright © 2006 Keith Packard
3 *
4 * Permission to use, copy, modify, distribute, and sell this software and its
5 * documentation for any purpose is hereby granted without fee, provided that
6 * the above copyright notice appear in all copies and that both that copyright
7 * notice and this permission notice appear in supporting documentation, and
8 * that the name of the copyright holders not be used in advertising or
9 * publicity pertaining to distribution of the software without specific,
10 * written prior permission. The copyright holders make no representations
11 * about the suitability of this software for any purpose. It is provided "as
12 * is" without express or implied warranty.
13 *
14 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
15 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
16 * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
17 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
18 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
19 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
20 * OF THIS SOFTWARE.
21 */
22
23 #include "randrstr.h"
24 #include "propertyst.h"
25 #include "swaprep.h"
26
27 static void
28 RRDeliverEvent (ScreenPtr pScreen, xEvent *event, CARD32 mask)
29 {
30
31 }
32
33 void
34 RRDeleteAllOutputProperties (RROutputPtr output)
35 {
36 RRPropertyPtr prop, next;
37 xRROutputPropertyNotifyEvent event;
38
39 for (prop = output->properties; prop; prop = next)
40 {
41 next = prop->next;
42 event.type = RREventBase + RRNotify;
43 event.subCode = RRNotify_OutputProperty;
44 event.output = output->id;
45 event.state = PropertyDelete;
46 event.atom = prop->propertyName;
47 event.timestamp = currentTime.milliseconds;
48 RRDeliverEvent (output->pScreen, (xEvent *) &event, RROutputPropertyNotifyMask);
49 if (prop->current.data)
50 xfree(prop->current.data);
51 if (prop->pending.data)
52 xfree(prop->pending.data);
53 xfree(prop);
54 }
55 }
56
57 static void
58 RRInitOutputPropertyValue (RRPropertyValuePtr property_value)
59 {
60 property_value->type = None;
61 property_value->format = 0;
62 property_value->size = 0;
63 property_value->data = NULL;
64 }
65
66 static RRPropertyPtr
67 RRCreateOutputProperty (Atom property)
68 {
69 RRPropertyPtr prop;
70
71 prop = (RRPropertyPtr)xalloc(sizeof(RRPropertyRec));
72 if (!prop)
73 return NULL;
74 prop->next = NULL;
75 prop->propertyName = property;
76 prop->is_pending = FALSE;
77 prop->range = FALSE;
78 prop->immutable = FALSE;
79 prop->num_valid = 0;
80 prop->valid_values = NULL;
81 RRInitOutputPropertyValue (&prop->current);
82 RRInitOutputPropertyValue (&prop->pending);
83 return prop;
84 }
85
86 static void
87 RRDestroyOutputProperty (RRPropertyPtr prop)
88 {
89 if (prop->valid_values)
90 xfree (prop->valid_values);
91 if (prop->current.data)
92 xfree(prop->current.data);
93 if (prop->pending.data)
94 xfree(prop->pending.data);
95 xfree(prop);
96 }
97
98 void
99 RRDeleteOutputProperty (RROutputPtr output, Atom property)
100 {
101 RRPropertyPtr prop, *prev;
102 xRROutputPropertyNotifyEvent event;
103
104 for (prev = &output->properties; (prop = *prev); prev = &(prop->next))
105 if (prop->propertyName == property)
106 break;
107 if (prop)
108 {
109 *prev = prop->next;
110 event.type = RREventBase + RRNotify;
111 event.subCode = RRNotify_OutputProperty;
112 event.output = output->id;
113 event.state = PropertyDelete;
114 event.atom = prop->propertyName;
115 event.timestamp = currentTime.milliseconds;
116 RRDeliverEvent (output->pScreen, (xEvent *) &event, RROutputPropertyNotifyMask);
117 RRDestroyOutputProperty (prop);
118 }
119 }
120
121 int
122 RRChangeOutputProperty (RROutputPtr output, Atom property, Atom type,
123 int format, int mode, unsigned long len,
124 pointer value, Bool sendevent, Bool pending)
125 {
126 RRPropertyPtr prop;
127 xRROutputPropertyNotifyEvent event;
128 rrScrPrivPtr pScrPriv = rrGetScrPriv(output->pScreen);
129 int size_in_bytes;
130 int total_size;
131 unsigned long total_len;
132 RRPropertyValuePtr prop_value;
133 RRPropertyValueRec new_value;
134 Bool add = FALSE;
135
136 size_in_bytes = format >> 3;
137
138 /* first see if property already exists */
139 prop = RRQueryOutputProperty (output, property);
140 if (!prop) /* just add to list */
141 {
142 prop = RRCreateOutputProperty (property);
143 if (!prop)
144 return(BadAlloc);
145 add = TRUE;
146 mode = PropModeReplace;
147 }
148 if (pending && prop->is_pending)
149 prop_value = &prop->pending;
150 else
151 prop_value = &prop->current;
152
153 /* To append or prepend to a property the request format and type
154 must match those of the already defined property. The
155 existing format and type are irrelevant when using the mode
156 "PropModeReplace" since they will be written over. */
157
158 if ((format != prop_value->format) && (mode != PropModeReplace))
159 return(BadMatch);
160 if ((prop_value->type != type) && (mode != PropModeReplace))
161 return(BadMatch);
162 new_value = *prop_value;
163 if (mode == PropModeReplace)
164 total_len = len;
165 else
166 total_len = prop_value->size + len;
167
168 if (mode == PropModeReplace || len > 0)
169 {
170 pointer new_data = NULL, old_data = NULL;
171
172 total_size = total_len * size_in_bytes;
173 new_value.data = (pointer)xalloc (total_size);
174 if (!new_value.data && total_size)
175 {
176 if (add)
177 RRDestroyOutputProperty (prop);
178 return BadAlloc;
179 }
180 new_value.size = len;
181 new_value.type = type;
182 new_value.format = format;
183
184 switch (mode) {
185 case PropModeReplace:
186 new_data = new_value.data;
187 old_data = NULL;
188 break;
189 case PropModeAppend:
190 new_data = (pointer) (((char *) new_value.data) +
191 (prop_value->size * size_in_bytes));
192 old_data = new_value.data;
193 break;
194 case PropModePrepend:
195 new_data = new_value.data;
196 old_data = (pointer) (((char *) new_value.data) +
197 (prop_value->size * size_in_bytes));
198 break;
199 }
200 if (new_data)
201 memcpy ((char *) new_data, (char *) value, len * size_in_bytes);
202 if (old_data)
203 memcpy ((char *) old_data, (char *) prop_value->data,
204 prop_value->size * size_in_bytes);
205
206 if (pending && pScrPriv->rrOutputSetProperty &&
207 !pScrPriv->rrOutputSetProperty(output->pScreen, output,
208 prop->propertyName, &new_value))
209 {
210 if (new_value.data)
211 xfree (new_value.data);
212 return (BadValue);
213 }
214 if (prop_value->data)
215 xfree (prop_value->data);
216 *prop_value = new_value;
217 }
218
219 else if (len == 0)
220 {
221 /* do nothing */
222 }
223
224 if (add)
225 {
226 prop->next = output->properties;
227 output->properties = prop;
228 }
229
230 if (pending && prop->is_pending)
231 output->pendingProperties = TRUE;
232
233 if (sendevent)
234 {
235 event.type = RREventBase + RRNotify;
236 event.subCode = RRNotify_OutputProperty;
237 event.output = output->id;
238 event.state = PropertyNewValue;
239 event.atom = prop->propertyName;
240 event.timestamp = currentTime.milliseconds;
241 RRDeliverEvent (output->pScreen, (xEvent *) &event, RROutputPropertyNotifyMask);
242 }
243 return(Success);
244 }
245
246 Bool
247 RRPostPendingProperties (RROutputPtr output)
248 {
249 RRPropertyValuePtr pending_value;
250 RRPropertyValuePtr current_value;
251 RRPropertyPtr property;
252 Bool ret = TRUE;
253
254 if (!output->pendingProperties)
255 return TRUE;
256
257 output->pendingProperties = FALSE;
258 for (property = output->properties; property; property = property->next)
259 {
260 /* Skip non-pending properties */
261 if (!property->is_pending)
262 continue;
263
264 pending_value = &property->pending;
265 current_value = &property->current;
266
267 /*
268 * If the pending and current values are equal, don't mark it
269 * as changed (which would deliver an event)
270 */
271 if (pending_value->type == current_value->type &&
272 pending_value->format == current_value->format &&
273 pending_value->size == current_value->size &&
274 !memcmp (pending_value->data, current_value->data,
275 pending_value->size))
276 continue;
277
278 if (RRChangeOutputProperty (output, property->propertyName,
279 pending_value->type, pending_value->format,
280 PropModeReplace, pending_value->size,
281 pending_value->data, TRUE,
282 FALSE) != Success)
283 ret = FALSE;
284 }
285 return ret;
286 }
287
288 RRPropertyPtr
289 RRQueryOutputProperty (RROutputPtr output, Atom property)
290 {
291 RRPropertyPtr prop;
292
293 for (prop = output->properties; prop; prop = prop->next)
294 if (prop->propertyName == property)
295 return prop;
296 return NULL;
297 }
298
299 RRPropertyValuePtr
300 RRGetOutputProperty (RROutputPtr output, Atom property, Bool pending)
301 {
302 RRPropertyPtr prop = RRQueryOutputProperty (output, property);
303
304 if (!prop)
305 return NULL;
306 if (pending && prop->is_pending)
307 return &prop->pending;
308 else
309 return &prop->current;
310 }
311
312 int
313 RRConfigureOutputProperty (RROutputPtr output, Atom property,
314 Bool pending, Bool range, Bool immutable,
315 int num_values, INT32 *values)
316 {
317 RRPropertyPtr prop = RRQueryOutputProperty (output, property);
318 Bool add = FALSE;
319 INT32 *new_values;
320
321 if (!prop)
322 {
323 prop = RRCreateOutputProperty (property);
324 if (!prop)
325 return(BadAlloc);
326 add = TRUE;
327 } else if (prop->immutable && !immutable)
328 return(BadAccess);
329
330 /*
331 * ranges must have even number of values
332 */
333 if (range && (num_values & 1))
334 return BadMatch;
335
336 new_values = xalloc (num_values * sizeof (INT32));
337 if (!new_values && num_values)
338 return BadAlloc;
339 if (num_values)
340 memcpy (new_values, values, num_values * sizeof (INT32));
341
342 /*
343 * Property moving from pending to non-pending
344 * loses any pending values
345 */
346 if (prop->is_pending && !pending)
347 {
348 if (prop->pending.data)
349 xfree (prop->pending.data);
350 RRInitOutputPropertyValue (&prop->pending);
351 }
352
353 prop->is_pending = pending;
354 prop->range = range;
355 prop->immutable = immutable;
356 prop->num_valid = num_values;
357 if (prop->valid_values)
358 xfree (prop->valid_values);
359 prop->valid_values = new_values;
360
361 if (add) {
362 prop->next = output->properties;
363 output->properties = prop;
364 }
365
366 return Success;
367 }
368
369 int
370 ProcRRListOutputProperties (ClientPtr client)
371 {
372 REQUEST(xRRListOutputPropertiesReq);
373 Atom *pAtoms = NULL, *temppAtoms;
374 xRRListOutputPropertiesReply rep;
375 int numProps = 0;
376 RROutputPtr output;
377 RRPropertyPtr prop;
378
379 REQUEST_SIZE_MATCH(xRRListOutputPropertiesReq);
380
381 output = LookupOutput (client, stuff->output, DixReadAccess);
382
383 if (!output)
384 return RRErrorBase + BadRROutput;
385
386 for (prop = output->properties; prop; prop = prop->next)
387 numProps++;
388 if (numProps)
389 if(!(pAtoms = (Atom *)ALLOCATE_LOCAL(numProps * sizeof(Atom))))
390 return(BadAlloc);
391
392 rep.type = X_Reply;
393 rep.length = (numProps * sizeof(Atom)) >> 2;
394 rep.sequenceNumber = client->sequence;
395 rep.nAtoms = numProps;
396 if (client->swapped)
397 {
398 int n;
399 swaps (&rep.sequenceNumber, n);
400 swapl (&rep.length, n);
401 }
402 temppAtoms = pAtoms;
403 for (prop = output->properties; prop; prop = prop->next)
404 *temppAtoms++ = prop->propertyName;
405
406 WriteReplyToClient(client, sizeof(xRRListOutputPropertiesReply), &rep);
407 if (numProps)
408 {
409 client->pSwapReplyFunc = (ReplySwapPtr)Swap32Write;
410 WriteSwappedDataToClient(client, numProps * sizeof(Atom), pAtoms);
411 DEALLOCATE_LOCAL(pAtoms);
412 }
413 return(client->noClientException);
414 }
415
416 int
417 ProcRRQueryOutputProperty (ClientPtr client)
418 {
419 REQUEST(xRRQueryOutputPropertyReq);
420 xRRQueryOutputPropertyReply rep;
421 RROutputPtr output;
422 RRPropertyPtr prop;
423
424 REQUEST_SIZE_MATCH(xRRQueryOutputPropertyReq);
425
426 output = LookupOutput (client, stuff->output, DixReadAccess);
427
428 if (!output)
429 return RRErrorBase + BadRROutput;
430
431 prop = RRQueryOutputProperty (output, stuff->property);
432 if (!prop)
433 return BadName;
434
435 rep.type = X_Reply;
436 rep.length = prop->num_valid;
437 rep.sequenceNumber = client->sequence;
438 rep.pending = prop->is_pending;
439 rep.range = prop->range;
440 rep.immutable = prop->immutable;
441 if (client->swapped)
442 {
443 int n;
444 swaps (&rep.sequenceNumber, n);
445 swapl (&rep.length, n);
446 }
447 WriteReplyToClient (client, sizeof (xRRQueryOutputPropertyReply), &rep);
448 if (prop->num_valid)
449 {
450 client->pSwapReplyFunc = (ReplySwapPtr)Swap32Write;
451 WriteSwappedDataToClient(client, prop->num_valid * sizeof(INT32),
452 prop->valid_values);
453 }
454 return(client->noClientException);
455 }
456
457 int
458 ProcRRConfigureOutputProperty (ClientPtr client)
459 {
460 REQUEST(xRRConfigureOutputPropertyReq);
461 RROutputPtr output;
462 int num_valid;
463
464 REQUEST_AT_LEAST_SIZE(xRRConfigureOutputPropertyReq);
465
466 output = LookupOutput (client, stuff->output, DixReadAccess);
467
468 if (!output)
469 return RRErrorBase + BadRROutput;
470
471 num_valid = stuff->length - (sizeof (xRRConfigureOutputPropertyReq) >> 2);
472 return RRConfigureOutputProperty (output, stuff->property,
473 stuff->pending, stuff->range,
474 FALSE, num_valid,
475 (INT32 *) (stuff + 1));
476 }
477
478 int
479 ProcRRChangeOutputProperty (ClientPtr client)
480 {
481 REQUEST(xRRChangeOutputPropertyReq);
482 RROutputPtr output;
483 char format, mode;
484 unsigned long len;
485 int sizeInBytes;
486 int totalSize;
487 int err;
488
489 REQUEST_AT_LEAST_SIZE(xRRChangeOutputPropertyReq);
490 UpdateCurrentTime();
491 format = stuff->format;
492 mode = stuff->mode;
493 if ((mode != PropModeReplace) && (mode != PropModeAppend) &&
494 (mode != PropModePrepend))
495 {
496 client->errorValue = mode;
497 return BadValue;
498 }
499 if ((format != 8) && (format != 16) && (format != 32))
500 {
501 client->errorValue = format;
502 return BadValue;
503 }
504 len = stuff->nUnits;
505 if (len > ((0xffffffff - sizeof(xChangePropertyReq)) >> 2))
506 return BadLength;
507 sizeInBytes = format>>3;
508 totalSize = len * sizeInBytes;
509 REQUEST_FIXED_SIZE(xRRChangeOutputPropertyReq, totalSize);
510
511 output = LookupOutput (client, stuff->output, DixWriteAccess);
512 if (!output)
513 return RRErrorBase + BadRROutput;
514
515 if (!ValidAtom(stuff->property))
516 {
517 client->errorValue = stuff->property;
518 return(BadAtom);
519 }
520 if (!ValidAtom(stuff->type))
521 {
522 client->errorValue = stuff->type;
523 return(BadAtom);
524 }
525
526 err = RRChangeOutputProperty(output, stuff->property,
527 stuff->type, (int)format,
528 (int)mode, len, (pointer)&stuff[1], TRUE, TRUE);
529 if (err != Success)
530 return err;
531 else
532 return client->noClientException;
533 }
534
535 int
536 ProcRRDeleteOutputProperty (ClientPtr client)
537 {
538 REQUEST(xRRDeleteOutputPropertyReq);
539 RROutputPtr output;
540
541 REQUEST_SIZE_MATCH(xRRDeleteOutputPropertyReq);
542 UpdateCurrentTime();
543 output = LookupOutput (client, stuff->output, DixWriteAccess);
544 if (!output)
545 return RRErrorBase + BadRROutput;
546
547 if (!ValidAtom(stuff->property))
548 {
549 client->errorValue = stuff->property;
550 return (BadAtom);
551 }
552
553
554 RRDeleteOutputProperty(output, stuff->property);
555 return client->noClientException;
556 }
557
558 int
559 ProcRRGetOutputProperty (ClientPtr client)
560 {
561 REQUEST(xRRGetOutputPropertyReq);
562 RRPropertyPtr prop, *prev;
563 RRPropertyValuePtr prop_value;
564 unsigned long n, len, ind;
565 RROutputPtr output;
566 xRRGetOutputPropertyReply reply;
567
568 REQUEST_SIZE_MATCH(xRRGetOutputPropertyReq);
569 if (stuff->delete)
570 UpdateCurrentTime();
571 output = LookupOutput (client, stuff->output,
572 stuff->delete ? DixWriteAccess :
573 DixReadAccess);
574 if (!output)
575 return RRErrorBase + BadRROutput;
576
577 if (!ValidAtom(stuff->property))
578 {
579 client->errorValue = stuff->property;
580 return(BadAtom);
581 }
582 if ((stuff->delete != xTrue) && (stuff->delete != xFalse))
583 {
584 client->errorValue = stuff->delete;
585 return(BadValue);
586 }
587 if ((stuff->type != AnyPropertyType) && !ValidAtom(stuff->type))
588 {
589 client->errorValue = stuff->type;
590 return(BadAtom);
591 }
592
593 for (prev = &output->properties; (prop = *prev); prev = &prop->next)
594 if (prop->propertyName == stuff->property)
595 break;
596
597 reply.type = X_Reply;
598 reply.sequenceNumber = client->sequence;
599 if (!prop)
600 {
601 reply.nItems = 0;
602 reply.length = 0;
603 reply.bytesAfter = 0;
604 reply.propertyType = None;
605 reply.format = 0;
606 WriteReplyToClient(client, sizeof(xRRGetOutputPropertyReply), &reply);
607 return(client->noClientException);
608 }
609
610 if (prop->immutable && stuff->delete)
611 return BadAccess;
612
613 if (stuff->pending && prop->is_pending)
614 prop_value = &prop->pending;
615 else
616 prop_value = &prop->current;
617
618 /* If the request type and actual type don't match. Return the
619 property information, but not the data. */
620
621 if (((stuff->type != prop_value->type) &&
622 (stuff->type != AnyPropertyType))
623 )
624 {
625 reply.bytesAfter = prop_value->size;
626 reply.format = prop_value->format;
627 reply.length = 0;
628 reply.nItems = 0;
629 reply.propertyType = prop_value->type;
630 WriteReplyToClient(client, sizeof(xRRGetOutputPropertyReply), &reply);
631 return(client->noClientException);
632 }
633
634 /*
635 * Return type, format, value to client
636 */
637 n = (prop_value->format/8) * prop_value->size; /* size (bytes) of prop */
638 ind = stuff->longOffset << 2;
639
640 /* If longOffset is invalid such that it causes "len" to
641 be negative, it's a value error. */
642
643 if (n < ind)
644 {
645 client->errorValue = stuff->longOffset;
646 return BadValue;
647 }
648
649 len = min(n - ind, 4 * stuff->longLength);
650
651 reply.bytesAfter = n - (ind + len);
652 reply.format = prop_value->format;
653 reply.length = (len + 3) >> 2;
654 if (prop_value->format)
655 reply.nItems = len / (prop_value->format / 8);
656 else
657 reply.nItems = 0;
658 reply.propertyType = prop_value->type;
659
660 if (stuff->delete && (reply.bytesAfter == 0))
661 {
662 xRROutputPropertyNotifyEvent event;
663
664 event.type = RREventBase + RRNotify;
665 event.subCode = RRNotify_OutputProperty;
666 event.output = output->id;
667 event.state = PropertyDelete;
668 event.atom = prop->propertyName;
669 event.timestamp = currentTime.milliseconds;
670 RRDeliverEvent (output->pScreen, (xEvent *) &event, RROutputPropertyNotifyMask);
671 }
672
673 WriteReplyToClient(client, sizeof(xGenericReply), &reply);
674 if (len)
675 {
676 switch (reply.format) {
677 case 32: client->pSwapReplyFunc = (ReplySwapPtr)CopySwap32Write; break;
678 case 16: client->pSwapReplyFunc = (ReplySwapPtr)CopySwap16Write; break;
679 default: client->pSwapReplyFunc = (ReplySwapPtr)WriteToClient; break;
680 }
681 WriteSwappedDataToClient(client, len,
682 (char *)prop_value->data + ind);
683 }
684
685 if (stuff->delete && (reply.bytesAfter == 0))
686 { /* delete the Property */
687 *prev = prop->next;
688 RRDestroyOutputProperty (prop);
689 }
690 return(client->noClientException);
691 }
692
A new scheduler for Xserver