Hay unos cuantos métodos para dibujar en un área de dibujo y todos requieren un contexto gráfico (gtk.gdk.GC) , que encapsula la información necesaria para dibujar. Los atributos de un contexto gráfico son:

background      # fondo
cap_style       # estilo de fin de linea
clip_mask       # máscara de recorte
clip_x_origin   # orígen x del rectángulo de recorte
clip_y_origin   # orígen y del rectángulo de recorte
fill            # relleno
font            # fuente
foreground      # color de frente
function        # función
graphics_exposures # exposiciones gráficas
join_style      # estilo de unión
line_style      # estilo de linea
line_width      # ancho de linea
stipple         # patrón de relleno
sub_window      # subventana
tile            # título
ts_x_origin     # orígen x
ts_y_origin     # orígen y

background (fondo) especifica el gtk.gdk.Color que se usa para dibujar el fondo.

foreground (frente) especifica el gtk.gdk.Color que se usa para dibujar el color de primer plano.

Para crear un gtk.gdk.Color se usa el método alloc_color() de la clase gtk.gdk.Colormap (Mapa de Color). El mapa de color asociado a un control se puede obtener con el método:

  colormap = widget.get_colormap()

Se puede especificar un gtk.gdk.Color cómo una cadena de texto (por ejemplo, "red" (rojo), "orange" (naranja), "navajo white" (blanco navajo) definida en el fichero rgb.txt de X Window), o cómo un triple de rojo, verde y azúl de enteros en el rango de 0 a 65535. Además, puedes especificar si el color es modificable (se puede cambiar después pero no puede compartirse) y si se debe hacer una búsqueda y quedarse con el color más parecido de entre los existentes si el color exacto no está disponible. El método alloc_color() se define así:

  color = colormap.alloc_color(red, green, blue, writeable=FALSE, best_match=TRUE)

  color = colormap.alloc_color(spec, writeable=FALSE, best_match=TRUE)

Por ejemplo:

  navajowhite = colormap.alloc('navajo white')

  cyan = colormap.alloc(0, 65535, 65535)

cap_style especifica el estilo de fin de linea que se usa cuando se dibuja el final de una linea que no esta unida a otras. Los estilos disponibles son:

clip_mask especifica un gtk.gdk.Pixmap que se usa para recortar el dibujo.

clip_x_origin y clip_y_origin especifican los valores x e y del orígen del rectángulo de recorte relativos a la esquina superior izquierda del drawing_area (área de dibujo).

fill especifica el estilo de relleno que se usará al dibujar. Los estilos de relleno disponibles son:

font es la gtk.gdk.Font (Fuente) que se usa cómo la fuente predeterminada para dibujar texto.

function especifica cómo se combinan los valores de los bits en los píxeles de orígen con los valores de los bits en los píxeles de destino para producir el resultado final. Los 16 valores diferentes se corresponden con las posibles tablas de verdad 2x2. Sólo un par de estos valores es útil normalmente; para imágenes a color, sólo COPY, XOR e INVERT generalmente son útiles. Para mapas de bits, AND y OR también suelen ser útiles. Los valores de función son:

  COPY        # Copiar
  INVERT      # Invertir
  XOR         # XOR
  CLEAR       # Limpiar
  AND         # Y
  AND_REVERSE # Y al revés
  AND_INVERT  # Y invertida
  NOOP        # Nada
  OR          # O
  EQUIV       # equivalencia
  OR_REVERSE  # O al revés
  COPY_INVERT # Copiar invertido
  OR_INVERT   # O invertido
  NAND        # NAND
  SET         # Fijar

graphics_exposures especifica si las exposiciones gráficas están activadas (TRUE) o desactivadas (FALSE). Cuando graphics_exposures es TRUE, un fallo al copiar un píxel en una operación de dibujo producirá un evento expose; si la copia tiene éxito, se producirá un evento noexpose.

join_style especifica el estilo de unión que se usa cuando las lineas se juntan en un ángulo. Los estilos disponibles son:

line_style especifica el estilo con el que se dibuja una linea. Los estilos disponibles son:

line_width especifica el ancho con el que se dibujan las lineas.

stipple especifica el gtk.gdk.Pixmap que se usará para dibujo con patrón cuando el relleno está puesto a STIPPLED o a OPAQUE_STIPPLED.

sub_window especifica el modo de dibujo de una gtk.gdk.Window que tiene hijas gtk.gdk.Window. Los valores posibles son:

tile especifica el gtk.gdk.Pixmap que se usará para dibujo cuadriculado cuando el relleno esta puesto a TILED.

ts_x_origin y ts_y_origin especifican la posición iniciales de los mapas de bits de patrón y de dibujo cuadriculado).

Se puede crear un nuevo Contexto Gráfico con una llamada al método gtk.gdk.Window new_gc() :

gc = widget.window.new_gc(foreground=None, background=None, font=None, 
                          function=-1, fill=-1, tile=None,
                          stipple=None, clip_mask=None, subwindow_mode=-1,
                          ts_x_origin=-1, ts_y_origin=-1, clip_x_origin=-1,
                          clip_y_origin=-1, graphics_exposures=-1,
                          line_width=-1, line_style=-1, cap_style=-1
                          join_style=-1)

Para crear un nuevo Contexto Gráfico con este método, el control debe ser del tipo de los que tienen una gtk.gdk.Window y el control debe estar realizado (es decir, la gtk.gdk.Window ha sido creada).

Los atributos del Contexto Gráfico pueden dejarse sin tocar o especificarse en el método new_gc() usando argumentos de palabras clave de Python.

Los atributos individuales de un gtk.gdk.GC se pueden establecer asignándole un valor al atributo. Por ejemplo:

  gc.cap_style = CAP_BUTT
  gc.line_width = 10
  gc.fill = SOLD
  gc.foreground = micolor

o usando los siguientes métodos:

  gc.set_foreground(color)
  gc.set_background(color)
  gc.set_function(function)
  gc.set_fill(fill)
  gc.set_tile(tile)
  gc.set_stipple(stipple)
  gc.set_ts_origin(x, y)
  gc.set_clip_origin(x, y)
  gc.set_clip_mask(mask)
  gc.set_clip_rectangle(rectangle)
  gc.set_subwindow(mode)
  gc.set_exposures(exposures)
  gc.set_line_attributes(line_width, line_style, cap_style, join_style)

El patrón intermitente que se usa cuando el estilo de linea es LINE_ON_OFF_DASH o LINE_DOUBLE_DASH se puede fijar usando el siguiente método:

  gc.set_dashes(offset, dash_list)

donde offset (desplazamiento) es el índice del valor inicial en dash_list y dash_list (lista de intermitencia) es una lista o tupla que contiene los números de los píxeles a dibujar o saltar para formar los segmentos. Los segmentos se dibujan empezando con el número de píxeles en la posición de desplazamiento; entonces, el siguiente número de píxeles no se dibuja; y luego el siguiente número es dibujado; y así, recorriendo todos los números de la lista de intermitencia y empezando otra vez cuando se llega al final. Por ejemplo, si la lista de intermitencia es (2, 4, 8, 16) y el desplazamiento es 1, los segmentos se dibujarán así: dibuja 4 píxeles, sáltate 8 píxeles, dibuja 16 píxeles, sáltate 2 píxeles, dibuja 4 píxeles y así sucesivamente.

Se puede copiar un gtk.gdk.GC existente usando el método:

  gc.copy(src_gc)

Los atributos de gc serán los mismos que los de src_gc.