Skip to content

# `fgLayer`

## fontgate.fgLayer = class fgLayer(object)

      Layer representation

      Constructors:
        fgLayer() - default
        fgLayer(fgLayer) - copy
        fgLayer('name') - create named layer

      Math operation:
        fgLayer + fgLayer
        fgLayer - fgLayer

#### Methods

__add__(...)

      x.__add__(y) <==> x+y

__cmp__(...)

      x.__cmp__(y) <==> cmp(x,y)

__delattr__(...)

      x.__delattr__('name') <==> del x.name

__delitem__(...)

      x.__delitem__(y) <==> del x[y]

__delslice__(...)

      x.__delslice__(i, j) <==> del x[i:j]

      Use of negative indices is not supported.

__getattribute__(...)

      x.__getattribute__('name') <==> x.name

__getitem__(...)

      x.__getitem__(y) <==> x[y]

__getslice__(...)

      x.__getslice__(i, j) <==> x[i:j]

      Use of negative indices is not supported.

__init__(...)

      x.__init__(...) initializes x; see help(type(x)) for signature

__len__(...)

      x.__len__() <==> len(x)

__mul__(...)

      x.__mul__(n) <==> x*n

__radd__(...)

      x.__radd__(y) <==> y+x

__repr__(...)

      x.__repr__() <==> repr(x)

__rmul__(...)

      x.__rmul__(n) <==> n*x

__rsub__(...)

      x.__rsub__(y) <==> y-x

__setattr__(...)

      x.__setattr__('name', value) <==> x.name = value

__setitem__(...)

      x.__setitem__(i, y) <==> x[i]=y

__setslice__(...)

      x.__setslice__(i, j, y) <==> x[i:j]=y

      Use  of negative indices is not supported.

__sub__(...)

      x.__sub__(y) <==> x-y

addContour(...)

      fgContour addContour(fgContour) - add contour to layer

boundingBox(...)

      fgRect/Nothing boundingBox(fgMatrix[, prepareExport = false])

checkContours(...)

      checkContours()

countContours(...)

      int countContours()

countHints(...)

      int countHints(bool horizontal)

countNodes(...)

      int countNodes()

countPictures(...)

      int countPictures()

countShapes(...)

      int countShapes()

findHint(...)

      int findHint(fgHint)

findNode(...)

      fgNode/Nothing findNode(nodeIndex / 'nodeName') - find name by index or name

hasColors(...)

      bool hasColors()

hasHints(...)

      bool hasHints()

hasPictures(...)

      bool hasPictures()

hints2links(...)

      hints2links(double tolerance[, fgCuspPoints])

indexToName(...)

      'nodeName' indexToName(int nodeIndex)

isCompatible(...)

      bool/Nothing isCompatible(flLayer)

nameToIndex(...)

      int nameToIndex('nodeName')

prepareNodeNames(...)

      prepareNodeNames()

removeHints(...)

      removeHints(bool horizontal)

transform(...)

      transform(const Matrix& mx[, apply = true])

#### Descriptors

active

      (bool)

anchors

      (fgAnchors)

guides

      (fgGuides)

hints

      (fgHints)

hintsProgram

      (fgHintCommands)

locked

      (bool)

matrix

      (fgMatrix)

name

      (string)

opacity

      (float)

reference

      (fgPoint)

service

      (bool)

visible

      (bool)

wireframe

      (bool)

#### Attributes

__new__ = <built-in method __new__ of type object>

      T.__new__(S, ...) -> a new object with type S, a subtype of T

## `active`

fontgate.fgLayer.active

      (bool)

## `addContour`

fontgate.fgLayer.addContour = addContour(...)

      fgContour addContour(fgContour) - add contour to layer

## `anchors`

fontgate.fgLayer.anchors

      (fgAnchors)

## `boundingBox`

fontgate.fgLayer.boundingBox = boundingBox(...)

      fgRect/Nothing boundingBox(fgMatrix[, prepareExport = false])

## `checkContours`

fontgate.fgLayer.checkContours = checkContours(...)

      checkContours()

## `countContours`

fontgate.fgLayer.countContours = countContours(...)

      int countContours()

## `countHints`

fontgate.fgLayer.countHints = countHints(...)

      int countHints(bool horizontal)

## `countNodes`

fontgate.fgLayer.countNodes = countNodes(...)

      int countNodes()

## `countPictures`

fontgate.fgLayer.countPictures = countPictures(...)

      int countPictures()

## `countShapes`

fontgate.fgLayer.countShapes = countShapes(...)

      int countShapes()

## `findHint`

fontgate.fgLayer.findHint = findHint(...)

      int findHint(fgHint)

## `findNode`

fontgate.fgLayer.findNode = findNode(...)

      fgNode/Nothing findNode(nodeIndex / 'nodeName') - find name by index or name

## `guides`

fontgate.fgLayer.guides

      (fgGuides)

## `hasColors`

fontgate.fgLayer.hasColors = hasColors(...)

      bool hasColors()

## `hasHints`

fontgate.fgLayer.hasHints = hasHints(...)

      bool hasHints()

## `hasPictures`

fontgate.fgLayer.hasPictures = hasPictures(...)

      bool hasPictures()

## `hints`

fontgate.fgLayer.hints

      (fgHints)

## `hints2links`

fontgate.fgLayer.hints2links = hints2links(...)

      hints2links(double tolerance[, fgCuspPoints])

## `hintsProgram`

fontgate.fgLayer.hintsProgram

      (fgHintCommands)

## `indexToName`

fontgate.fgLayer.indexToName = indexToName(...)

      'nodeName' indexToName(int nodeIndex)

## `isCompatible`

fontgate.fgLayer.isCompatible = isCompatible(...)

      bool/Nothing isCompatible(flLayer)

## `locked`

fontgate.fgLayer.locked

      (bool)

## `matrix`

fontgate.fgLayer.matrix

      (fgMatrix)

## `name`

fontgate.fgLayer.name

      (string)

## `nameToIndex`

fontgate.fgLayer.nameToIndex = nameToIndex(...)

      int nameToIndex('nodeName')

## `opacity`

fontgate.fgLayer.opacity

      (float)

## `prepareNodeNames`

fontgate.fgLayer.prepareNodeNames = prepareNodeNames(...)

      prepareNodeNames()

## `reference`

fontgate.fgLayer.reference

      (fgPoint)

## `removeHints`

fontgate.fgLayer.removeHints = removeHints(...)

      removeHints(bool horizontal)

## `service`

fontgate.fgLayer.service

      (bool)

## `transform`

fontgate.fgLayer.transform = transform(...)

      transform(const Matrix& mx[, apply = true])

## `visible`

fontgate.fgLayer.visible

      (bool)

## `wireframe`

fontgate.fgLayer.wireframe

      (bool)