rom/graphics/obtainpen.c

   1 /*
   2     Copyright © 1995-2007, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Obtain a certain pen
   6     Lang: english
   7 */
   8 #include "graphics_intern.h"
   9 #include <graphics/view.h>
  10
  11 /*****************************************************************************
  12
  13     NAME */
  14         #include <proto/graphics.h>
  15
  16         AROS_LH6(LONG, ObtainPen,
  17
  18 /*  SYNOPSIS */
  19         AROS_LHA(struct ColorMap *, cm   , A0),
  20         AROS_LHA(ULONG            , n    , D0),
  21         AROS_LHA(ULONG            , r    , D1),
  22         AROS_LHA(ULONG            , g    , D2),
  23         AROS_LHA(ULONG            , b    , D3),
  24         AROS_LHA(ULONG            , flags, D4),
  25
  26 /*  LOCATION */
  27         struct GfxBase *, GfxBase, 159, Graphics)
  28
  29 /*  FUNCTION
  30         Attempt to allocate an entry in the colormap for exclusive
  31         or shared use by the application. To deallocate the pen
  32         ReleasePen() must be called.
  33
  34     INPUTS
  35         cm    - A pointer to a color map structure
  36         n     - index of the entry in the color map; if any entry is fine
  37                 pass -1
  38         r     - red value (left justified 32 bit fraction)
  39         g     - green value (left justified 32 bit fraction)
  40         b     - blue value (left justified 32 bit fraction)
  41         flags - PEN_EXCLUSIVE - for exclusive access to a color register;
  42                               default is shared access
  43
  44                 PEN_NO_SETCOLOR - will not change the RGB values
  45                                   for the selected pen.
  46
  47     RESULT
  48         n  = allocated pen number, -1 for failure
  49
  50     NOTES
  51         Shared palette entries should not be changed (via SetRGB??())
  52         since other applications might use the same color.
  53         A PaletteExtra structure must have been attached to the
  54         ColorMap prior to calling this function (AttachPalExtra()).
  55
  56     EXAMPLE
  57
  58     BUGS
  59
  60     SEE ALSO
  61
  62     INTERNALS
  63
  64     HISTORY
  65
  66 *****************************************************************************/
  67 {
  68     AROS_LIBFUNC_INIT
  69
  70     LONG retval = -1;
  71     PalExtra_AllocList_Type index;
  72     BOOL was_shared = FALSE;
  73     /*
  74        Change the calculation of the color if the entries
  75        in the colortable attached to the colormap structure
  76        are changed
  77     */
  78     struct PaletteExtra * pe = cm->PalExtra;
  79
  80     ObtainSemaphore(&pe->pe_Semaphore);
  81
  82     /* pe_SharableColors is not the number of colors but the last color index! */
  83
  84     if (NULL != pe && (n <= pe->pe_SharableColors || -1 == n ))
  85     {
  86         if (-1 != n)
  87         {
  88             /* A specific color map entry is requested */
  89             /* Does the user want shared or exclusive access ? */
  90
  91             if (0 != (flags & PENF_EXCLUSIVE))
  92             {
  93                 /* EXCLUSIVE ACCESS to pen */
  94                 if (pe->pe_FirstFree == n)
  95                 {
  96                     /* it is the very first one of available pens */
  97                     retval = n;
  98
  99                     pe->pe_NFree--;
 100
 101                     if ((PalExtra_AllocList_Type)-1 == PALEXTRA_ALLOCLIST(pe, n))
 102                         pe->pe_FirstFree = (UWORD)-1;
 103                     else
 104                         pe->pe_FirstFree = PALEXTRA_ALLOCLIST(pe, n);
 105
 106                     /* mark that entry as used */
 107                     PALEXTRA_ALLOCLIST(pe, n) = (PalExtra_AllocList_Type)-1;
 108
 109                 } /* if (pe->pe_FirstFree == n) */
 110                 else
 111                 {
 112                     /*
 113                        walk through the list of free entries and see whether
 114                        the requested one is still available.
 115                     */
 116                     index = (PalExtra_AllocList_Type)pe->pe_FirstFree;
 117
 118                     while ((PalExtra_AllocList_Type)-1 != index)
 119                     {
 120                         if (n == PALEXTRA_ALLOCLIST(pe, index))
 121                         {
 122                             /* it's still free! So I allocate it */
 123                             retval = n;
 124                             PALEXTRA_ALLOCLIST(pe, index) = PALEXTRA_ALLOCLIST(pe, n);
 125                             PALEXTRA_ALLOCLIST(pe, n) = (PalExtra_AllocList_Type)-1;
 126                             pe->pe_NFree--;
 127                             break;
 128                         }
 129                         else
 130                             index = PALEXTRA_ALLOCLIST(pe, index);
 131
 132                     } /* while */
 133
 134                 } /* (pe->pe_FirstFree != n) */
 135
 136             } /* if (EXCLUSIVE access) */
 137             else
 138             {
 139                 /* SHARED ACCESS to pen */
 140                 /*
 141                    the pen could already be shared or it can still be in
 142                    the free list.
 143                    I recognize that a pen is already shared by its entry
 144                    in pe_RefCnt being != 0.
 145                 */
 146                 if (PALEXTRA_REFCNT(pe, n) != 0)
 147                 {
 148                     /*
 149                        this one is already in shared mode, so test
 150                        whether the color is the same.
 151                        ??? Is this necessary for a shared pen?
 152                     */
 153                     if (color_equal(cm,r,g,b,n))
 154                     {
 155                         /* increase the RefCnt */
 156                         PALEXTRA_REFCNT(pe, n)++;
 157                         was_shared = TRUE;
 158                         retval = n;
 159                     }
 160                 } /* if PALEXTRA_REFCNT(pe, n) != 0) */
 161                 else
 162                 {
 163                     /*
 164                     ** The RefCnt is 0, so the pen is probably still in the
 165                     ** free list unless it is an exclusive pen.
 166                     */
 167                     if (pe->pe_FirstFree == n)
 168                     {
 169                         /* it is the very first one of available pens */
 170                         retval = n;
 171
 172                         if ((PalExtra_AllocList_Type)-1 == PALEXTRA_ALLOCLIST(pe, n))
 173                             pe->pe_FirstFree = (UWORD)-1;
 174                         else
 175                             pe->pe_FirstFree = (UWORD)PALEXTRA_ALLOCLIST(pe, n);
 176                         /* mark that entry as shared */
 177
 178                     } /* if (pe->pe_FirstFree == n) */
 179                     else
 180                     {
 181                         /*
 182                            walk through the list of free entries and see whether
 183                            the requested one is still available
 184                         */
 185                         index = (PalExtra_AllocList_Type)pe->pe_FirstFree;
 186
 187                         while ((PalExtra_AllocList_Type)-1 != index)
 188                         {
 189                             if ((PalExtra_AllocList_Type)n == PALEXTRA_ALLOCLIST(pe, index))
 190                             {
 191                                 /* it's still free! So I allocate it */
 192                                 retval = n;
 193                                 PALEXTRA_ALLOCLIST(pe, index) = PALEXTRA_ALLOCLIST(pe, n);
 194
 195                                 break;
 196                             }
 197                             else
 198                                 index = PALEXTRA_ALLOCLIST(pe, index);
 199
 200                         } /* while */
 201
 202                     } /* (pe->pe_FirstFree != n) */
 203
 204                     if (-1 != retval)
 205                     {
 206                         PALEXTRA_ALLOCLIST(pe, n) = (PalExtra_AllocList_Type)pe->pe_FirstShared;
 207                         pe->pe_FirstShared = n;
 208                         pe->pe_NFree--;
 209                         pe->pe_NShared++;
 210                         PALEXTRA_REFCNT(pe, n) = 1;
 211                     }
 212
 213                 } /* (PALEXTRA_REFCNT(pe, n) == 0) */
 214
 215             } /* shared access */
 216
 217         } /* n != -1 */
 218         else
 219         {
 220             /* Any entry in the color table is fine */
 221
 222             /* Does the user want shared or exclusive access ? */
 223             if (0 != (flags & PENF_EXCLUSIVE))
 224             {
 225                 /* EXCLUSIVE ACCESS to pen */
 226                 /*
 227                 ** Search for the very first entry that I can
 228                 ** give exclusive access to, if there are still
 229                 ** entries free
 230                 */
 231                 if (0 != pe->pe_NFree)
 232                 {
 233                     retval = pe->pe_FirstFree;
 234                     pe->pe_NFree--;
 235                     if (0 == pe->pe_NFree)
 236                         pe->pe_FirstFree = (UWORD)-1;
 237                     else
 238                         pe->pe_FirstFree = (UWORD)PALEXTRA_ALLOCLIST(pe, retval);
 239                     PALEXTRA_ALLOCLIST(pe, retval) = (PalExtra_AllocList_Type)-1;
 240                     PALEXTRA_REFCNT(pe, retval) = 0;
 241                 }
 242
 243             } /* if (0 != (flags & PENF_EXCLUSIVE)) */
 244             else
 245             {
 246                 /* SHARED ACCESS */
 247                 /*
 248                 ** Search for the very first entry that I can give
 249                 ** shared access to. First search the list of shared
 250                 ** colors and look for matching colors and if nothing can
 251                 ** be found there then take an entry out of the
 252                 ** free list.
 253                 */
 254                 index = (PalExtra_AllocList_Type)pe->pe_FirstShared;
 255                 while ((PalExtra_AllocList_Type)-1 != index)
 256                 {
 257                     if (color_equal(cm,r,g,b,index))
 258                     {
 259                         /* That's a good one */
 260                         retval = index;
 261                         PALEXTRA_REFCNT(pe, retval)++;
 262                         was_shared = TRUE;
 263                         break;
 264                     }
 265                     index = PALEXTRA_ALLOCLIST(pe, index);
 266                 }
 267
 268                 /*
 269                 ** If nothing was found take an entry from the free list
 270                 */
 271                 if (-1 == retval && 0 != pe->pe_NFree)
 272                 {
 273                     retval = pe->pe_FirstFree;
 274                     pe->pe_NFree--;
 275                     if (0 == pe->pe_NFree)
 276                         pe->pe_FirstFree = (UWORD)-1;
 277                     else
 278                         pe->pe_FirstFree = (UWORD)PALEXTRA_ALLOCLIST(pe, retval);
 279
 280                     PALEXTRA_ALLOCLIST(pe, retval) = (PalExtra_AllocList_Type)pe->pe_FirstShared;
 281                     pe->pe_FirstShared = retval;
 282                     PALEXTRA_REFCNT(pe, retval) = 1;
 283                     pe->pe_NShared++;
 284                 }
 285
 286             } /* shared access */
 287
 288         } /* n = -1 */
 289
 290     } /* if (NULL != pe && (n <= pe->pe_SharableColors || -1 == n )) */
 291
 292     if (-1 != retval && 0 == (flags & PENF_NO_SETCOLOR) && !was_shared)
 293     {
 294         /* Change the rgb values for the selected pen */
 295
 296         if (pe->pe_ViewPort)
 297         {
 298             SetRGB32(pe->pe_ViewPort, retval, r, g, b);
 299         } else {
 300             SetRGB32CM(cm, retval, r, g, b);
 301         }
 302     }
 303
 304     ReleaseSemaphore(&pe->pe_Semaphore);
 305
 306     return retval;
 307
 308     AROS_LIBFUNC_EXIT
 309 } /* ObtainPen */