DOKK / manpages / debian 12 / tk8.6-doc / Tk_GetColorFromObj.3tk.en
Tk_AllocColorFromObj(3tk) Tk Library Procedures Tk_AllocColorFromObj(3tk) 







Tk_AllocColorFromObj, Tk_GetColor, Tk_GetColorFromObj,
    Tk_GetColorByValue, Tk_NameOfColor, Tk_FreeColorFromObj, Tk_FreeColor -
    maintain database of colors








#include <tk.h>

XColor *
Tk_AllocColorFromObj(interp, tkwin, objPtr)

XColor *
Tk_GetColor(interp, tkwin, name)

XColor *
Tk_GetColorFromObj(tkwin, objPtr)

XColor *
Tk_GetColorByValue(tkwin, prefPtr)

const char *
Tk_NameOfColor(colorPtr)

GC
Tk_GCForColor(colorPtr, drawable)

Tk_FreeColorFromObj(tkwin, objPtr)

Tk_FreeColor(colorPtr)









  
Tcl_Interp *interp (in)

  
Interpreter to use for error reporting.

  
Tk_Window tkwin (in)

  
Token for window in which color will be used.

  
Tcl_Obj *objPtr (in/out)

  
String value describes desired color; internal rep will be modified to
      cache pointer to corresponding (XColor *).

  
char *name (in)

  
Same as objPtr except description of color is passed as a string
      and resulting (XColor *) is not cached.

  
XColor *prefPtr (in)

  
Indicates red, green, and blue intensities of desired color.

  
XColor *colorPtr (in)

  
Pointer to X color information. Must have been allocated by previous call
      to Tk_AllocColorFromObj, Tk_GetColor or
      Tk_GetColorByValue, except when passed to
    Tk_NameOfColor.

  
Drawable drawable (in)

  
Drawable in which the result graphics context will be used. Must have same
      screen and depth as the window for which the color was allocated.
    
    

    

  










These procedures manage the colors being used by a Tk application.
    They allow colors to be shared whenever possible, so that colormap space is
    preserved, and they pick closest available colors when colormap space is
    exhausted.


Given a textual description of a color,
    Tk_AllocColorFromObj locates a pixel value that may be used to render
    the color in a particular window. The desired color is specified with a
    value whose string value must have one of the following forms:



  

  
Any of the valid textual names for a color defined in the server's color
      database file, such as red or PeachPuff.

  
#RGB

  

  
#RRGGBB

  

  
#RRRGGGBBB

  

  
#RRRRGGGGBBBB

  
A numeric specification of the red, green, and blue intensities to use to
      display the color. Each R, G, or B represents a
      single hexadecimal digit. The four forms permit colors to be specified
      with 4-bit, 8-bit, 12-bit or 16-bit values. When fewer than 16 bits are
      provided for each color, they represent the most significant bits of the
      color, while the lower unfilled bits will be repeatedly replicated from
      the available higher bits. For example, #3a7 is the same as
    #3333aaaa7777.




Tk_AllocColorFromObj returns a pointer to an XColor
    structure; the structure indicates the exact intensities of the allocated
    color (which may differ slightly from those requested, depending on the
    limitations of the screen) and a pixel value that may be used to draw with
    the color in tkwin. If an error occurs in Tk_AllocColorFromObj
    (such as an unknown color name) then NULL is returned and an error message
    is stored in interp's result if interp is not NULL. If the
    colormap for tkwin is full, Tk_AllocColorFromObj will use the
    closest existing color in the colormap. Tk_AllocColorFromObj caches
    information about the return value in objPtr, which speeds up future
    calls to procedures such as Tk_AllocColorFromObj and
    Tk_GetColorFromObj.


Tk_GetColor is identical to Tk_AllocColorFromObj
    except that the description of the color is specified with a string instead
    of a value. This prevents Tk_GetColor from caching the return value,
    so Tk_GetColor is less efficient than
  Tk_AllocColorFromObj.


Tk_GetColorFromObj returns the token for an existing color,
    given the window and description used to create the color.
    Tk_GetColorFromObj does not actually create the color; the color must
    already have been created with a previous call to
    Tk_AllocColorFromObj or Tk_GetColor. The return value is
    cached in objPtr, which speeds up future calls to
    Tk_GetColorFromObj with the same objPtr and tkwin.


Tk_GetColorByValue is similar to Tk_GetColor except
    that the desired color is indicated with the red, green, and
    blue fields of the structure pointed to by colorPtr.


This package maintains a database of all the colors currently in
    use. If the same color is requested multiple times from Tk_GetColor
    or Tk_AllocColorFromObj (e.g. by different windows), or if the same
    intensities are requested multiple times from Tk_GetColorByValue,
    then existing pixel values will be re-used. Re-using an existing pixel
    avoids any interaction with the window server, which makes the allocation
    much more efficient. These procedures also provide a portable interface that
    works across all platforms. For this reason, you should generally use
    Tk_AllocColorFromObj, Tk_GetColor, or
    Tk_GetColorByValue instead of lower level procedures like
    XAllocColor.


Since different calls to this package may return the same shared
    pixel value, callers should never change the color of a pixel returned by
    the procedures. If you need to change a color value dynamically, you should
    use XAllocColorCells to allocate the pixel value for the color.


The procedure Tk_NameOfColor is roughly the inverse of
    Tk_GetColor. If its colorPtr argument was created by
    Tk_AllocColorFromObj or Tk_GetColor then the return value is
    the string that was used to create the color. If colorPtr was created
    by a call to Tk_GetColorByValue, or by any other mechanism, then the
    return value is a string that could be passed to Tk_GetColor to
    return the same color. Note: the string returned by Tk_NameOfColor is
    only guaranteed to persist until the next call to Tk_NameOfColor.


Tk_GCForColor returns a graphics context whose
    foreground field is the pixel allocated for colorPtr and whose
    other fields all have default values. This provides an easy way to do basic
    drawing with a color. The graphics context is cached with the color and will
    exist only as long as colorPtr exists; it is freed when the last
    reference to colorPtr is freed by calling Tk_FreeColor.


When a color is no longer needed Tk_FreeColorFromObj or
    Tk_FreeColor should be called to release it. For
    Tk_FreeColorFromObj the color to release is specified with the same
    information used to create it; for Tk_FreeColor the color to release
    is specified with a pointer to its XColor structure. There should be exactly
    one call to Tk_FreeColorFromObj or Tk_FreeColor for each call
    to Tk_AllocColorFromObj, Tk_GetColor, or
    Tk_GetColorByValue.








color, intensity, value, pixel value







  

    8.1
    Tk