# ALBERT User Manual

Everything ALBERT can do and the keys and gestures that do it. This is the manual
shown in the application under **Help → User Manual**, so it stays free of
anything that only makes sense with the source code at hand.

Modifier keys are written for Windows and Linux; on macOS, **Cmd** stands in for
**Ctrl** throughout.

## Colors

ALBERT's everyday controls live on rounded **dashboards** floating over the
drawing area: the tools along the top, and two bars at the bottom - the brush
and texture strip, and below it the palette bar with the color slots. The
dashboards follow the window as it resizes. Press **Tab** (or **View → Show
Dashboards**) to hide them for an unobstructed look at the artwork, and again
to bring them back.

- **Left mouse** draws with the primary color, **right mouse** with the secondary;
  select them in the palette bar with a left/right click respectively.
  **Options → Pen Width…** sets the stroke width (1–32 pixels)
- **The number keys pick the primary color** without going to the bar: **1** to
  **8** select the first eight palette colors, **Shift+1** to **Shift+8** the
  other eight, in the order the bar shows them. The bar's selection follows, so
  it still pictures what the pen paints
- **The color slots** (right of the palette bar) hold the colors the C64 shares
  across the whole image rather than per char cell; left-click a slot to assign
  the primary color, right-click for the secondary. Each slot is drawn as a
  miniature screen filled with the color it currently assigns, with a light
  marker showing exactly what it recolors: the bitmap rectangle for the
  background, the
  frame or the side bars for the border, a strip along the top or bottom for a
  border background, and a small sprite for a sprite color (with its companion
  sprite marked faintly beside it, so the pair reads together). Hovering a
  slot names it.
  Background recolors the canvas; the two sprite multicolors recolor both
  side-border sprite strips.
  Only the slots the canvas actually has appear: hires has no global background, so
  it shows the border alone; multicolor adds the background; and a multicolor
  canvas with side borders shows the background plus the two sprite multicolors;
  there the frame around the canvas takes the
  global background color rather than a border color of its own, so the
  background slot sets it and
  no border slot is needed. Canvases that are not exactly one screen have no
  border frame at all (see *Files*), so the border slot disappears there too; a
  dual-screen hires canvas shows no slots. A top/bottom-borders canvas adds per-border slots
  instead: background and two sprite multicolors for the top border, the same
  for the bottom (hires keeps just the two
  backgrounds); each recoloring only its own border strip, so the two borders
  can use fully independent color sets; the global background then covers the
  bitmap area alone, and the border slot shows the side borders (see below).
  However many slots a canvas has, they all sit on one row
- **The side borders slot** (top/bottom-borders canvases, both hires and
  multicolor) is the color of the plain border left and right of the drawable
  area, which the sprite strips do not reach; its miniature screen highlights
  the two side bars. It is the same border color other
  canvases' border slot sets, shown for what it colors here; like the border it
  only sets a color, since the border holds no pixels you can draw on
- **Palette → Pixcen/Pepto/Colodore/CCS64/PC64/VICE/Jampal/DeeKay/NTSC/High
  Contrast** picks which RGB values the 16 C64 colors render as; the emulators and
  tools disagree, so match whichever you compare your work against. It's a display
  choice only: the artwork is indexed, nothing in the image changes, and the
  variant isn't stored in the project file

## Brushes and textures

- **Options → Round/Square Brush** picks the nib shape; the two buttons at the
  left of the texture dashboard do the same. On a rotated view the
  nib stays upright on the screen by default; hold **Ctrl** (Cmd on macOS) to
  align it to the canvas axes instead; only observable with the square nib,
  and previewed live under the cursor. The **-** and **+** buttons beside them
  step the pen width (hold to repeat), the same width **Options → Pen Width…**
  sets; from the keyboard `,` or `[` steps it down and `.` or `]` up, a held
  key repeating just as a held button does
- **The texture bar** (the strip sitting on top of the palette bar) selects a
  paint pattern; 16×16,
  anchored to the canvas so strokes tile seamlessly; the strip's first tile is
  the solid pen. The swatches show what each pattern produces and never change:
  hires and multicolor documents each carry their own drawing of every pattern,
  made for that mode's pixel shape, and the bar hands you the right one for the
  document at hand. The selection returns to the solid pen whenever you start
  or open a document. White cells
  paint the stroke's color; black cells paint the
  *other* color (**Options → Two-Color Texture**, clash-friendly in hires) or
  stay untouched (**Options → Texture Stencil**, the default: a pattern then
  layers over what is already there and touches nothing else)
- **Right-click a pattern** to select its negative instead: white and black
  cells swap, so in **Texture Stencil** the pattern touches exactly the pixels
  it left alone before, and in **Two-Color Texture** the two colors trade
  places. The slot shows the negative while it is selected, so the bar always
  pictures what the pen paints; left-click the slot again for the pattern as
  drawn. The first tile is the exception: it is the solid pen, its negative
  would paint nothing, so a right-click there selects the solid pen like a
  left-click
- **Tablet/stylus pressure** widens the stroke live: full pressure adds 16 to the
  selected pen width, on a quadratic response curve for finer control at light
  touch; mouse strokes always use the selected width. **Options → Pressure-
  Widened Strokes** (on by default) turns this off: unchecked, tablet strokes
  paint at the selected width too
- **Why the toggle:** a line whose weight follows the hand is what you want when
  you are drawing, painting or sketching, and it is quicker than reaching for
  the width control between strokes. Pixel-level work wants the opposite. There
  every pixel is placed on purpose, and a width that drifts with how hard you
  happen to be pressing lays down pixels you did not ask for and have to clean
  up; a pressure-widened stroke also gives up strict single-pixel rendering,
  since its width changes as the stroke goes. Leave the option on while you
  block a picture in, and turn it off for the pass where you are placing
  individual pixels: the stylus then paints at exactly the selected width, the
  way the mouse does, and you keep it for pointing accuracy alone

## Strokes

- **Options → Pixel-Perfect Strokes** renders single-pixel lines strictly:
  exactly one pixel per step, never doubled at row/column crossings (lenient
  rendering, the default, is faithful to a round 1px nib but can leave chunky
  spots on shallow or steep lines). Freehand strokes also thin their corners,
  as pixel-perfect modes in mainstream pixel art editors do: where the stroke
  turns a right angle, the corner pixel is dropped, so slowly drawn diagonals
  come out as clean one-pixel staircases. The pixel under the cursor stays
  provisional until the stroke moves on or ends, so you can watch a corner
  vanish as you turn; tablet strokes widened by pressure keep the plain
  strict rendering
- **Options → Anti-Aliased Strokes** blends the edges of wide pen strokes into
  the picture on multicolor canvases: each edge pixel takes the palette color
  nearest to the mix of the stroke color and what was underneath, so the C64
  palette itself supplies the in-between shades, just as pixel artists
  anti-alias by hand (where the palette has no shade between two colors, the
  edge stays hard). The eraser blends the same way, softening toward the color
  it erases to. Multicolor only: hires char cells hold just two colors, which
  leaves no room for blended shades, so the option is unavailable on hires
  canvases and hires strokes always paint hard-edged. Shape outlines
  anti-alias too: the choice latches when the shape is created, like its
  other paint properties, and a filled shape keeps a solid interior with a
  blended rim. Single-pixel strokes are
  never anti-aliased either (at width 1 a pixel is either painted or not), so
  the option is unavailable at pen width 1 too, unless Pressure-Widened
  Strokes is switched on, which lets a stylus push the stroke past one pixel.
  Flood fills always paint hard-edged, but a *contour* from the same tool does
  blend, being stroked rather than flooded. The color limits still apply:
  where the blended shades would put too many colors in a char cell or sprite,
  the extra ones merge into the nearest surviving color. The option is a
  per-session choice and starts switched off at every launch
- **Shift+press** rubber-bands a connecting line from the previous stroke's endpoint:
  the pending line previews solid while the button is held (adjust the endpoint freely,
  e.g. to minimize color clashes) and releasing commits exactly the previewed segment.
  The brush footprint is previewed under the cursor at all times; previews are the
  exact result a stroke would leave, including any clash recoloring of char cells.
  Holding **Ctrl** at the same time suppresses it; Shift+Ctrl is also the Redo
  chord (Ctrl+Shift+Z), so the connecting-line preview no longer flashes on screen
  when you press Shift as part of that shortcut

## Symmetry draw

- **Options → Symmetry** mirrors your brush strokes in real time, producing
  symmetrical designs effortlessly. Every copy paints through the same pipeline
  as your own stroke; textures, clash rules, and previews included, so the
  hover preview shows all copies before you click:
  - **None** (the default) does not mirror your strokes
  - **Horizontal** mirrors on either side of the horizontal line that splits
    the canvas into an upper and lower half
  - **Vertical** mirrors on either side of the vertical line that splits the
    canvas into a left and right half
  - **Quadrant** splits the canvas horizontally and vertically, mirroring your
    strokes to the three other areas
  - **Bi-Quadrant** further splits each quadrant in two diagonally, with the
    splitting diagonals serving as additional axes of symmetry; eight mirrored
    copies in all
  - **Kaleidoscope** replicates your strokes rotationally instead: eight copies
    at 45° steps around the axes' intersection
- Green lines drawn on the canvas serve as a visual guide for indicating the
  locations of the mirroring; in Kaleidoscope mode the axes of symmetry are
  drawn in yellow. Angles are true to the emulated display (on double-wide
  multicolor pixels and under PAL/NTSC emulation a diagonal guide is 45°
  *as you see it*) and the square nib rotates and mirrors with each copy,
  so every copy is an exact counterpart of your stroke
- The axes start at the canvas center, and you can put them wherever your
  design needs them: **Options → Symmetry → Move Axes** (press **Y**) turns
  drags into axis moves instead of strokes. Grab an axis line, the cursor
  becomes a splitter over one, and it follows the cursor, landing on pixel
  boundaries and pixel centers alike; in Quadrant mode grabbing the
  intersection moves both axes together, and in Bi-Quadrant and Kaleidoscope
  (whose diagonals hinge on the intersection) dragging anywhere moves it.
  Clicks never paint while the tool is active. **Options → Symmetry → Reset
  Axes to Center** puts the axes back, from any tool
- **Options → Symmetry → Apply to Flood Fill** extends the mirroring to the
  fill tool: one click floods every copy's area; each fill runs on its own
  from the mirrored click point, so a copy that lands somewhere unfillable
  simply does nothing while the others proceed, and a single undo removes
  them all. Off by default: leave it unchecked and fills stay single even
  while your strokes mirror
- **Options → Symmetry → Apply to Shapes** does the same for the shape tool:
  the staged shape keeps its single set of handles, and its mirrored copies
  appear live in the preview (adjust the shape and watch all of them follow,
  clash resolution included) then land together at commit as one undoable
  edit. Also off by default
- Undo treats a symmetric stroke as one edit: a single undo removes all its
  copies, and the Shift connecting line anchors to *your* stroke's endpoint,
  never to a mirrored copy's. Symmetry is a drawing aid, not part of the
  artwork: the mode is not saved with the project, and every session starts
  with symmetry off

## Tools

- **The tools are one set of radio buttons**: exactly one is active at any
  time, picking one drops the one before it, and picking the one already
  active changes nothing (so no shortcut can turn a tool off by accident).
  The pen is a tool like the others, not a state you fall back into: it is
  the tool every session and every document starts with, and the one to pick
  when you are done with another
- **The tool dashboard** at the top of the drawing area carries a button per
  tool: pen, eraser, fill, shapes, eyedropper, pan, and selection. Each button
  mirrors its menu entry below (same toggle, same shortcut). The shapes
  button **wears the active shape** as its face, with a small dropdown caret in
  its corner: **clicking** it activates the shape tool with the shape shown, and
  **resting the pointer on it** opens the list of available shapes, hollow and
  filled, to pick another. Choosing one makes it the button's face and
  activates the tool (the current pick is check-marked; hovering names each
  shape). The **selection button works the same way**: it wears the active
  marquee (rectangle or lasso), a click uses it, and resting the pointer on it
  opens a list to pick the other. How long the pointer must dwell before either
  list opens is the **Hover delay** under **Edit → Settings → Tool Pickers**
  (half a second by default; the two pickers share the one value)
- **Options → Pen Tool** (press **B**) is freehand drawing: strokes follow the
  pointer, with the brush shape and width, textures, symmetry, clash rules and
  previews described above. Everything else in this section is a departure from
  it, and picking the pen is how you come back
- **Options → Fill Tool** (press **G**) switches clicks to flood fill: left fills
  the connected same-color area with the primary color, right with the secondary;
  the active texture applies (patterned fills), clash rules judge the fill at its
  starting pixel, and the hover preview shows the exact post-fill result before
  you click. That preview covers as much of the canvas as the fill would, so
  moving the pointer across flat artwork can repaint large areas over and over.
  **Options → Disable Fill Preview** turns it off: the fill itself is unchanged,
  you simply click without seeing the result first. The setting is remembered
  between sessions, and no other tool's preview is affected. Contours are the one
  exception: holding Ctrl brings the preview back even with this switched off,
  because what the setting silences is a whole area flashing on and off as you
  sweep, and a contour only ever changes a thin band
- **Hold Ctrl** (Cmd on macOS) while the fill tool is active and the click draws
  a **contour** instead of a fill: the same connected area is found, but only its
  edge is painted, as a band drawn with the current brush width, nib and texture
- Contours are for **multicolor** canvases. A hires cell allows two colors and a
  band is a thin thing crossing a great many cells, so on hires the outline would
  come back chewed through wherever the art it traces is not already monochrome;
  multicolor's four colors per cell leave it room. On a hires canvas the chord
  simply has no effect (you get the plain fill it modifies) and the placement
  menu below is greyed out
- **Options → Fill Contour Placement** decides where the band sits, and Ctrl
  applies whichever is selected: **Center** (the default) straddles the edge,
  **Outside** sits wholly beyond it, **Inside** wholly within. Outside is how you
  wrap a shape in an outline without losing a pixel of it. All three are as thick
  as the brush is wide, so changing the placement moves the band without changing
  how heavy it reads. At brush width 1 the band is one whole canvas pixel wide,
  the smallest mark the pen can make, exactly as a width-1 stroke is
- The placement lasts for the session and is deliberately not remembered between
  launches: it is the only thing deciding what Ctrl does, and every launch
  starting at Center means the chord never does something you set days ago and
  have forgotten. Change it while the pointer is resting on an area and the
  preview re-draws in the new placement straight away, so you can try all three
  against your artwork before committing to any of them
- Contours obey everything a fill obeys: the texture patterns them, symmetry
  mirrors them when **Apply to Flood Fill** is on, clash rules resolve them as
  they land, the hover preview shows the result before you click (press or
  release Ctrl and it re-draws without moving the pointer, and it shows even if
  **Disable Fill Preview** is checked), and a single undo removes one. Two
  details are worth knowing: an area running to the edge of
  the canvas is not traced along that edge, since the canvas rim is a frame
  rather than an edge of your shape; and clicking the *background* around a shape
  with Outside puts the band inside the shape instead, which is the same trick
  read the other way round
- **Options → Eyedropper Tool** (press **I**) switches clicks to color sampling:
  left picks up the color under the cursor as the primary pen color, right as
  the secondary, and dragging keeps sampling as you move. Nothing is painted and
  nothing lands in the undo history; the palette bar follows the sampled colors.
  While the plain pen is active you don't need the menu at all: **hold Alt** and
  the pen becomes the eyedropper for as long as the key is down; Alt+click or
  Alt+right-click samples, release Alt and you're drawing again. Whenever
  sampling is armed the cursor becomes a dropper and the brush preview hides.
  (On Windows, tapping Alt *without* clicking moves focus to the menu bar, as
  in any Windows program; press Alt again or click the canvas to continue)
- **Options → Eraser Tool** (press **E**) draws exactly like the plain pen -
  the same freehand strokes, and holding **Shift** erases a straight connecting
  line from where your last stroke ended, just as it draws one - but instead of a
  pen color it clears pixels to the mode's background: in multicolor that is the
  bitmap's background color, and in hires (which has no shared background) it is
  the secondary color. Both mouse buttons erase to that same color. The hover
  preview shows the exact result before you press, and everything the pen honors
  (the brush shape and width, textures, clash rules, and the undo history)
  applies unchanged
- **Options → Pan Tool** (press **H**) turns a plain left drag into panning the
  view, for moving around a zoomed canvas without holding anything down. It is
  the same pan the temporary gestures give you (hold **Space** and drag, or
  drag with the **middle button**, under any tool); nothing is painted and the
  artwork never changes
- **Options → Shape Tool** (press **S**) drags out shapes that stay adjustable
  after you draw them. Nothing touches the canvas until you commit: shapes are
  *staged*, and the preview shows the exact result, clash recoloring included,
  the whole time. Because the stage holds every shape you've drawn, you can nudge
  one shape after drawing another and watch their *joint* clash resolution update
  live, which is the reason the tool works this way:
  - **Options → Shape → Line/Rectangle/Circle/Star/Path** picks what a drag creates,
    and **Filled Shapes** whether closed shapes fill (a Line and a Path never fill)
  - **Corner-to-corner drag** creates a shape; left button for the primary
    colors, right for the secondary, like a stroke. The box follows the screen
    axes by default; hold **Ctrl** (Cmd on macOS) to align it to the canvas axes
    instead. **Shift** constrains to uniform aspect *on the emulated display* (a
    square, a true circle) and previews the shape's main diagonal while held, so
    you can see the constraint is on. A **Line** drag lays a straight segment
    from where you press to where you release, and a **Path** drag captures your
    freehand line instead; both are movable, rotatable, and scalable afterwards
    like any other shape (the encompassing box carries the corner handles), but
    never fill
  - **Colors, fill, outline width, nib, anti-aliasing, and texture latch when
    the shape is
    created**, so later tool changes never restyle what the preview already
    promised. Instead, changing one of those while shapes are *selected*
    re-applies it to the selection; drag a rectangle, click a palette color, as
    in any vector editor. Shape kind is geometry and never re-targets: a staged
    circle won't become a star
  - **Click a shape** to select and move it; **Shift+click** adds or removes one
    from the selection; the key above Tab (the backtick ` on a US keyboard, the
    section sign on an Apple US/UK keyboard) cycles the selection through the
    staged shapes; clicking empty canvas deselects and starts
    a new shape. **Delete** removes the selected shapes. **Arrows** nudge by one
    canvas pixel and **Shift+arrows** by one char cell, the step that matters
    when hunting for a clash-free placement against the attribute grid
  - **Handles appear when exactly one shape is selected**: four corner handles
    scale it (the opposite corner stays put; **Shift** keeps the aspect uniform,
    **Alt** drags that one corner alone and skews the shape into a trapezoid), the
    pin above the top edge rotates it (**Shift** snaps to 22.5° steps), and
    Rectangle and Star get four diagonal handles for the corner radius and the
    star's inner points
  - **Ctrl+Z while shapes are staged** undoes the last stage step (an add, a
    delete, a move, a property change) and leaves the document history alone;
    once the stage is empty it walks real history again. **Enter** (Edit → Commit
    Shapes) commits the whole stage as **one** undoable entry however long you
    fiddled, and switching tools commits too; **Esc** (Edit → Discard Shapes)
    throws the stage away and records nothing, so it asks you to confirm
    first: the stage is not part of the undo history, and a discarded stage
    cannot be brought back. Esc part-way through drawing or dragging a shape
    backs out of that one gesture and asks nothing. Pan, zoom, and rotate stay
    live while staging: rough a shape in, zoom, nudge a handle, commit
  - A staged shape is **not saved in the project file**, only committed history
    is, so commit before saving or quitting. Closing the application with
    shapes still staged prompts you to save, and answering Save commits them
    for you
- **Options → Rectangle Select Tool** (press **M**) and **Lasso Select Tool**
  (press **L**) mark off an area to work on, outlined with marching ants:
  - **The modifier held when the drag starts** decides how it composes with what's
    already selected, on the Photoshop convention: **Shift** adds, **Alt**
    subtracts, **Shift+Alt** intersects, unmodified replaces. A plain click
    deselects, and a **right-click deselects** anywhere on the canvas
  - **The marquee follows the screen axes** by default; hold **Ctrl** (Cmd) for
    the canvas axes, as everywhere else. It composes live, so the ants always show
    what you'd get; the lasso previews as a dashed guide and composes on release.
    A selection is an arbitrary region, not a rectangle, so a screen-aligned
    marquee on a rotated view lands as exactly the shape you outlined
  - **Edit → Select All** (Ctrl+A), **Deselect** (Ctrl+D, or Esc), and **Invert
    Selection** (Ctrl+Shift+I). Select All switches to the Rectangle Select tool
    when neither selection tool is on, so the selection it makes is ready to drag,
    nudge, or undo right away. While a selection tool is active, **Ctrl+Z** undoes
    selection changes before it touches the document history, so undoing past a
    deselect brings the selection back
  - **Edit → Cut/Copy/Paste** work on the selected pixels. The clipboard is
    internal to ALBERT and holds C64 color indices rather than RGB, so a paste
    re-derives through whatever palette variant you're on, survives starting a new
    canvas, and clips to it. **Cut** vacates the area to the blank color: the
    background in multicolor, and (since hires has no global background) the
    secondary pen color there. Cutting clears the pixels but leaves the
    selection outline in place, so you can paste straight back into the same
    area, refill it, or move it
  - **Copy** and **Cut** also place the selection on your system clipboard as a
    plain image, so you can paste it straight into other applications. This is a
    one-way hand-off out of ALBERT: pasting inside ALBERT still uses its own
    color-index clipboard. In multicolor mode the exported image widens each pixel
    to match its on-screen proportions, and a lasso selection exports with the area
    outside its outline left transparent
  - **Paste** (and **Paste with Transparency**, Ctrl+Shift+V) drops the clipboard
    at the position it was copied from and leaves it *floating*: drag it into
    place, and the canvas underneath is untouched until you commit. A transparent
    float's blank-color pixels let what's beneath show through. If the copied
    position is scrolled out of view, the paste appears at the center of the
    view instead, shifted by whole char cells, so the content keeps the same
    cell alignment it was copied with
  - **Dragging from inside the ants** floats the selected pixels the same way. Both
    drags *move*, the area you lifted from vacates to the blank color when you
    drop, and **Ctrl+drag** additionally makes the float transparent, so its
    blank-color pixels don't cover what it lands on. Shift, Alt, and Shift+Alt
    still compose even when the drag starts inside, so every composition mode stays
    reachable wherever you press (to copy rather than move, use Copy and Paste)
  - **Arrows nudge a float** by one canvas pixel, **Shift+arrows** by one char
    cell. **Enter**, Deselect, clicking outside, or switching tools drops it as one
    undoable edit however long you spent positioning it; **Esc** or **Ctrl+Z**
    discards it and leaves no trace, with the canvas underneath unchanged (this
    is how you remove a floating selection without altering what is beneath it).
    Clashes under a float resolve in real time as
    you drag, so what you see is what the drop commits

## The view

- **Mouse wheel** zooms in integer steps anchored under the cursor; **Edit →
  Settings** can invert which way it goes; **space-drag** or
  **middle-drag** pans; the View menu has zoom in/out, 100%, and best-fit
- **The arrow keys** pan by exactly one char cell a press, so the char grid
  lands back on itself every time and you can step across the artwork cell by
  cell. The step follows the canvas, not the screen: on a rotated view Right
  moves the artwork along the canvas's own horizontal, which is a diagonal
  slide on screen, the same direction Right nudges a floating selection or a
  staged shape. Those nudges come first, so while something is staged the
  arrows move it and the view holds still
- **R+drag** rotates the view around the viewport center; hold **Shift** (at the
  click or any time mid-drag) to snap to 22.5° steps. Rotation is bounded to ±180°
  so you never wind up whole turns; **View → Reset Rotation** (Ctrl+R) restores
  upright without the canvas jumping, and **Reset Rotation & Best Fit** (Ctrl+Home)
  does that and re-fits the canvas in one go
- **View → Show Reference Grids** (Shift+H) overlays the char-cell and sprite
  boundaries, the units clash rules apply to, so it's the grid that tells you
  where a color limit will bite; **Show Pixel Grids** (Shift+Z) outlines
  individual pixels, and only draws from 4× zoom up where it would be legible.
  Pressing **Z** switches both grids between their normal grey and a lighter
  one, for when a line is hard to pick out against the artwork under it
- **View → Show Safe Frames** overlays two translucent frames on canvases with
  border sprites: the areas of the canvas that VICE's C64 emulator displays
  with the VIC-II borders set to **Normal** (green, 384×272 square pixels) and
  to **Full** (amber, 408×293), that is, where it's safe to set border pixels
  and still have them shown under each border setting. Both frames are
  positioned relative to the bitmap area (the entry is disabled on canvases
  without border sprites, where no pixels exist outside it)
- **View → Show Reference Layer** shows or hides the reference image imported
  with **File → Import Reference Image…**; see that entry for what the layer
  is; **Reference Layer Opacity…** opens a slider for the strength it blends
  over the artwork with, applying live as you drag (Cancel restores the value
  the dialog opened with). Both entries wake up once a reference image has
  been imported
- **View → Square/PAL/NTSC Pixels** emulates the video standard's pixel aspect by
  stretching the view vertically; the brush height compensates so the nib keeps its
  proportions on the emulated display rather than being stretched with it; a round
  nib stays round, a square one stays square
- **View → Bilinear Filtering** softens the magnified artwork: zoomed in, pixels
  blend into their neighbours instead of showing as hard-edged blocks; a quick
  way to judge how the image reads as a picture rather than as pixels. One toggle
  for both the main canvas and the preview window, and display-only: no pixel is
  changed, and grids and overlays stay crisp on top. The preview's CRT emulation
  always draws with this softening as part of its look, so while that filter is
  on the toggle makes no difference there
- **View → Show Preview Window** (F8, from either window) opens a second view
  of the canvas
  in its own window: no grids, tool previews, or selection outlines; just the
  artwork and its border frame, updating live as you draw. It zooms and pans
  independently of the main view with the same gestures and shortcuts (wheel,
  left- or middle-drag to pan, zoom in/out, 100%, best-fit), so whichever window has
  the focus is the one the keys drive. It stays upright, Reset Rotation & Best
  Fit (Ctrl+Home) therefore just best-fits here, and follows
  the pixel aspect: multicolor's wide pixels and the Square/PAL/NTSC emulation
- **View → Preview Stays on Top** keeps the preview window above all other
  windows, ALBERT's and other applications', so it works as a live reference
  while you draw maximized. It steps aside on its own whenever ALBERT shows a
  message or progress dialog, so a dialog waiting for you is never hidden
  behind the preview
- **View → Mirror Preview Horizontally** (W, from either window) flips the
  preview window's image
  left-to-right. It is a drawing aid for judging symmetry, a mirrored view makes
  a lopsided face or an off-centre shape jump out, and nothing more: no pixel is
  moved or changed, the artwork is untouched, and the main canvas keeps showing it
  the right way round
- **View → Enable CRT Filter in Preview Window** (Alt+F8, from either window)
  renders the preview
  window the way a cathode-ray television showed a C64: the red and blue
  channels smear a pixel either side of the green one the way a composite or
  RF connection fringed colour, alternate scanlines are dimmed, and the
  picture is softened rather than shown with hard pixel edges. It is a
  display filter for that window alone; the artwork is not touched, and the
  main canvas keeps its crisp pixels for drawing
- The **status bar** along the bottom reports, left to right, the canvas mode
  and layout, its size in pixels, the display pixel aspect, the brush shape and
  width, the zoom, the view rotation, and the char cell and sprite the pointer
  is over (a dash when it is over neither). The fields keep fixed proportions
  of the window's width, so they never shift about as their values change;
  narrow the window far enough and a field shortens its text, with the whole
  value in its tooltip
- The rightmost status bar field reports results that leave no other trace in
  the window: a project opened or saved, an image or sprites imported, an image
  converted, an export written, a PRG sent to an Ultimate device. It reports a
  change of mind the same way: closing a file chooser or a prompt without
  choosing, or cancelling a save, open, export, conversion or send that is
  already running, leaves a note saying which operation was cancelled. That way
  a menu entry that ends with nothing visibly different never looks as though it
  did nothing at all. Each message
  clears itself after a few seconds. Anything that needs your attention, an
  error or a question, comes as a dialog instead, so nothing important is lost
  if you miss a line here
- A handful of shortcuts work the same whichever of the main window or the
  preview window has focus, rather than being scoped to one: **Zoom In**,
  **Zoom Out**, **Actual Size** (Ctrl+0), **Best Fit** (Ctrl+Shift+0), and
  **Reset Rotation & Best Fit** (Ctrl+Home) drive whichever window's view is
  active; **Show Preview Window** (F8), **Mirror Preview Horizontally** (W),
  and **Enable CRT Filter in Preview Window** (Alt+F8) toggle the same way
  regardless of which window you're looking at. Every other shortcut,
  including **Reset Rotation** (Ctrl+R), which only makes sense for the main
  view since the preview never rotates, is scoped to the main window

## Color clashes

- **Options → Hires Clash Resolution** selects the hires clash victim strategy:
  replace the overwritten color (default), preserve the border color, or preserve
  the most-used color. The submenu is available only while a hires document is
  open; multicolor documents resolve clashes by their own rules
- Everything you draw, paste, import, convert, or transform is kept clash-free
  as it happens, so a canvas only holds clashes when it arrived with them: a
  project file written by an earlier version of ALBERT can carry them in. The
  C64-native exports refuse such a canvas and offer the remedy in the message
  that says so. Choose **Resolve and Export** and the *clash sweep* runs across
  the whole canvas as one undoable edit, then the export goes ahead: each
  violating char cell or sprite keeps its most-used colors, and each color that
  has to go becomes whichever of the surviving colors is closest to it. Choose
  **Cancel** and the canvas is left exactly as it was, with nothing written.
  The same sweep is what the operations below mean when they say they end by
  resolving clashes

## Sprites in the top and bottom borders

- On a top/bottom-borders canvas each border strip shows 13 whole sprites plus
  an 8-pixel sliver of a 14th across the bitmap width. A border's two stacked
  sprite rows share their free color (the display hardware cannot change it
  between them), so a sprite's color reaches 42 lines; the reference grid
  still marks the 21-line hardware boundary through the middle of each strip,
  with a bracket at each end of the strip linking the two rows it joins.
  Each border draws with its own shared colors (the T-*/B-* slots in the color
  assignment bar) plus that one free color per sprite; the side borders are
  plain frame here, not drawable
- **Options → Border Sprites** aligns each border's sprite grid to the **left
  or right** bitmap edge; the truncated 14th sprite sits at the opposite end.
  Flipping an alignment moves the sprite boundaries the color rules and the
  reference grid use, so artwork that sat inside one sprite can end up
  straddling two. The flip therefore ends by resolving the sprites the new
  boundaries leave over their color limit: each keeps its most-used colors and
  the rest merge into the closest survivor, exactly as the clash sweep
  does. That merge is the only pixel the flip repaints, and all of it - the
  new alignment and the merged colors - is one undoable edit, so a single
  Undo brings back both
- The C64 has 8 hardware sprites, so at most 8 sprites in each border can hold
  pixels; a sprite counts as soon as it shows a single pixel in any colour
  other than its border's background. For all practical purposes a border's
  sprites are 42 lines tall: the display hardware shows the same 8 sprites in
  both of a border's 21-line rows, at the same horizontal positions, so a
  sprite with pixels in either row spends the slot for the whole border. The
  top and bottom borders are independent, each with its own 8. **Enforce
  8-Sprite Border Limit** and **Flag Sprites over the Border Limit** (Options →
  Border Sprites) choose whether drawing into a 9th sprite is blocked or merely
  flagged; the choice is saved with the project
- Under **Enforce**, a stroke keeps filling the sprites it already started but
  simply leaves no pixels in a 9th one; the brush preview shows that before
  you click. Erasing (drawing in the border's background color) is never
  blocked, and pixels already in a 9th sprite are never removed: enforcement
  only stops new ones appearing
- A **red frame** around a sprite means the C64 cannot display it as drawn, and
  it appears under both policies. What it flags in practice is a border holding
  more than 8 sprites: the excess ones are framed, those with the fewest
  non-background pixels, the very sprites Reduce Borders (below) would erase,
  with ties broken toward the border's aligned edge. An alignment flip can
  produce this out of artwork that was within the budget, by splitting one
  occupied sprite across the new boundaries. Erase the flagged sprites, or
  reduce the border (below). The frame also marks a sprite using more than one
  free color, but nothing you do here leaves one behind: drawing keeps each
  sprite within its color limit as you go, and every edit that moves sprite
  boundaries or colors, an alignment flip included, resolves the sprites it
  breaks. Such a sprite reaches you only in a project file written by an
  earlier version of ALBERT, and the clash sweep the native exports offer
  merges its extra colors away
- **Options → Border Sprites → Reduce Borders to 8 Sprites** brings each border
  back within the budget as one undoable edit: the 8 sprites with the most
  non-background pixels survive, and the rest are erased to their border's
  background. When two sprites hold the same number of pixels, the one nearer
  the border's aligned edge wins: the leftmost on a left-aligned border, the
  rightmost on a right-aligned one. Borders already within the budget are left
  untouched

## Editing

- **Edit → Undo/Redo** (Ctrl+Z / Ctrl+Y) walks every edit (strokes, color
  assignments, Clear Screen) with unlimited depth back to the first change; edits
  that end up changing no pixels (e.g. painting an area in its own color) don't
  clutter the history, and undoing a stroke also rewinds where the next
  Shift-connecting line starts
- **Edit → Clear History** discards the whole record of changes after asking you
  to confirm. The canvas keeps exactly the content it has on screen; only the
  record goes: nothing is left to undo or redo, the picture as it stands becomes
  the only workstage (so there is no sequence left to save), and the next
  Shift-connecting line has no earlier stroke to start from.
  This cannot be undone
- **Edit → Color Swap** (Alt+X) **/ Color Replace** (Alt+A) recolors the
  artwork between
  the two pen colors as one undoable edit. **Color Swap** exchanges the
  primary and secondary colors everywhere; every pixel of one becomes the
  other, in both directions. **Color Replace** turns every pixel of the
  secondary color into the primary, merging the two; pick the color to
  retire with a right click in the palette bar and the color to keep with a
  left click. The shared color slots follow the same exchange: a background,
  border, or sprite common set to a color being swapped or replaced moves
  with its pixels (in a swap, in both directions), so background pixels stay
  the free background color instead of turning into clashes and sprite
  commons keep matching their recolored pixels. **With a selection active,
  the recolor is confined to the selected pixels**, and the common sprite
  colors are left in place so sprites outside the selection keep their
  colors. The one exception is a selection that fully covers both side
  borders (multicolor side-border sprites), or a whole top or bottom border
  (multicolor top/bottom sprites): there the covered border's own common
  colors follow the exchange, since moving them affects nothing outside the
  selection. Neither operation can
  create a clash by itself; each still ends with the clash
  sweep, so clashes already flagged on the canvas are merged away at the
  same time. Swapping or replacing colors the artwork and slots never use
  changes nothing and records nothing
- **Edit → Transform → Flip Horizontally** (Ctrl+J) **/ Flip Vertically**
  (Ctrl+K) mirrors the artwork. **With a selection active it flips the
  selected content only** (the items say so, reading *Flip Selection
  Horizontally/Vertically*) and it does that as a **floating selection**: the
  mirrored content previews in
  place with live clash resolution, and you drag, nudge, or flip it again
  before **Enter** drops it as one undoable edit (**Esc** abandons it, leaving
  the canvas exactly as it was). Flipping a selection you have just pasted
  works the same way, and flipping twice is exactly the original back, pixel
  for pixel. The content mirrors about the selection's own bounding box, so it
  stays where it is; a non-rectangular (lasso) selection mirrors as a whole
  shape, and wherever the mirrored shape no longer covers the original,
  the vacated pixels are left in the blank color. A selection whose bounding
  box lines up with the char grid and is a whole number of cells across maps
  cells onto cells and so can never introduce a clash; an off-grid one lands
  the content at a different phase against the grid and can, in which case the
  drop resolves it like any other. With **no** selection the same two items
  mirror the whole
  artwork as one undoable edit, ending with the clash sweep so
  any clashes the mirroring creates are merged away. Bitmap content lands
  exactly back on the char grid, but the side-border sprite rows sit
  asymmetrically (their top and bottom rows are cropped), so a vertical flip
  can land sprite colors across sprite boundaries; the sweep then merges
  them. On a hires canvas with side-border sprites the mirror covers the
  editable 408 pixels: the locked 8-pixel border column stays put and the two
  sprite strips trade places exactly. On a top/bottom-borders canvas the
  sprite grids and border color slots follow the artwork; a horizontal flip
  flips both borders' left/right alignments, a vertical flip swaps the two
  borders' alignments and color slots, so legal sprites stay legal
- **Options → Clear Screen** (Ctrl+L) blanks the canvas to the mode's blank color;
  one undoable edit, not a new document
- **Edit → Settings…** holds the preferences that are set rather than
  toggled from a menu. The **General** group carries three view preferences,
  all off out of the box. **Invert Scroll Wheel Direction for Zooming**
  flips which way the wheel zooms (scroll down to zoom in) on the canvas
  and in the preview window alike, for those who prefer it that way; the
  **Zoom In** and **Zoom Out** entries and their shortcuts are unaffected.
  **Bind Zoom to Canvas**: with it on, the point **Zoom In**/**Zoom Out** works
  around is kept inside the drawable canvas, so zooming while the pointer is
  over the border, or with the canvas off to one side of the window, pulls
  the artwork back into view instead of magnifying empty space.
  **Smooth Scaling for Imported Images** controls how an imported image is
  resampled when it doesn't match the canvas: the reference layer and the
  **Convert Image…** input. Off (the default for a pixel art editor), a
  scaled image keeps hard pixel edges, and the reference layer stays blocky
  when you zoom in, like the artwork under it; on, both are filtered
  smoothly, which suits photographic sources. It applies as an image is
  imported, so change it before importing; an image already loaded keeps
  the scaling it arrived with (re-import to change it); the reference
  layer's on-screen sharpness follows the setting immediately.
  **Use OS-Native File Chooser Dialogs**, off out of the box, decides which
  file chooser opens for **Open**, the imports, the exports and the rest.
  Left off you get ALBERT's own, which add a preview
  pane: **Open** renders the project you have highlighted, **Import
  Image** and **Import Sprites** decode the file and show it as it will
  land, with the import's own options (the target screen on a two-screen
  canvas, the sprite attribute convention) beside the preview, so choosing
  the file and its settings is one step. Turn it on for the system's own
  chooser, the one your other applications use, with its bookmarks and
  network places: it has no pane to add any of that to, so those options are
  asked for in a small dialog after the file is picked instead, and nothing
  is previewed. On Linux the system chooser is available only on
  desktops that provide one; where none is, ALBERT's own opens whatever this
  is set to. On macOS the
  group ends with a fourth preference, **Use OS-Native Menu Bar**, off out of
  the box: ALBERT's menus sit in a menu bar inside the window, as on Windows
  and Linux, where they follow ALBERT's own appearance and where **Open
  Recent** can show its preview bubble. Turn it on to move them to the macOS
  menu bar at the top of the screen, where a Mac application's menus are
  expected; at the cost of that bubble and that appearance, both of which
  macOS draws its own way, and gaining back the row of window space the
  in-window bar takes up. The keyboard shortcuts are the
  same either way, and the menus move as soon as you click OK. The
  **Ultimate Device** group sets the host (IP address or hostname,
  192.168.0.64 out of the box) and the network timeout in seconds (2.5 out of
  the box, and anywhere from 0.1 to 60) that **File → Export to Ultimate
  Device** talks to the device with. The timeout is how long a send waits on a
  device that has gone quiet before giving up on it. OK
  keeps the values across sessions; Cancel changes nothing

## Files

- **File → Presets → Hires/Multicolor Canvas** starts a fresh single-screen
  project;
  **Hires + Side Sprites** and **Multicolor + Side Sprites** add the side-border
  sprite strips (two sprites wide each side, with the C64 sprite color rules
  enforced there; hires sprites share the border color, multicolor sprites the
  MC0/MC1 commons); **Hires + Top/Bottom Sprites** and **Multicolor +
  Top/Bottom Sprites** put the sprites in the top and bottom borders instead;
  two 21-line sprite rows above the bitmap and two below extend the drawable
  area to 320×284 on screen (see *Sprites in the top and bottom borders*);
  **Dual Hires Canvas** and **Dual Multicolor Canvas** put two screens
  of the respective mode side by side (640×200 on screen, one continuous cell
  grid; the seam is cell-aligned and marked by a brighter line in the
  reference grid). Only a canvas of exactly one screen, with or without sprite
  strips, is drawn with the border frame: the frame is one C64 screen's worth
  of border, and nothing frames a multi-screen or oversize canvas, or a free
  size smaller than a screen. Where there is no frame the border color slot
  disappears with it, in the main window, the preview window and the Convert
  Image dialog alike, and an image export of such a canvas does not offer to
  include the borders
- **File → New Canvas…** (Ctrl+N) is the same thing with the choices spelled out: mode,
  the sprite layout (bitmap only, side borders, top/bottom borders), screens
  across, and a free canvas size that snaps to whole
  char cells, with the resulting on-screen size shown as you go. The **Presets**
  submenu holds one-click presets for the common layouts. Starting a new canvas
  either way prompts you to save the current project first, before the New
  Canvas dialog opens, so the choices you make in the dialog are never thrown
  away by that prompt
- **File → Open / Save / Save As…** (Ctrl+Shift+S for Save As) read and write `.alb` project files: the
  colormap, the colors, and the full edit history, so a reopened project undoes
  back through everything you did before saving. Unless you have switched to
  the system file chooser (**Use OS-Native File Chooser Dialogs**, above),
  the Open dialog previews the
  highlighted project as you browse (the saved image in your current palette,
  with its mode, on-screen size, and workstage count under it) and reads only
  the picture itself, so browsing stays quick however long the history behind a
  file. The picture keeps its true on-screen size, or a whole multiple of it
  when the canvas is small enough for one to fit, so its pixels stay exact;
  only a canvas too large for the pane, such as a multi-screen one, is scaled
  down. Dragging a single `.alb` from your file manager onto the ALBERT window
  opens it the same way, prompting to save the current project first if it has
  unsaved changes
- An installed ALBERT registers itself as the application that opens `.alb`
  projects on **macOS** and **Linux** alike, so double-clicking one in the
  Finder or your file manager opens it here, as does dropping one on the
  macOS Dock icon, and projects carry their own icon instead of a blank-page
  one. On macOS you can open a project this way while ALBERT is already
  running; either way it prompts to save the current project first, exactly as
  **File → Open** does. On Linux the same registration puts ALBERT under
  Graphics in your application launcher. Windows keeps whatever association
  you set yourself, and opens a project handed to it on the command line
- **File → Open Recent** lists the last ten projects you opened or saved,
  newest first, each numbered for quick keyboard picking, and two projects
  sharing a file name are told apart by the folder shown beside it. Hovering
  an entry pops up a preview of what you'd be opening: the saved picture in
  your current palette, with its metadata beneath. Like the Open dialog's
  pane it sizes the picture the same way and reads only the picture itself,
  so the bubble is quick however long
  the history behind a project, and an entry that can no longer be read as a
  project says why instead. (With **Use OS-Native Menu Bar** on, macOS draws
  the menu itself and hovering shows the plain path alone.) Opening or saving a project already on the list
  moves it back to the top rather than adding it twice. Entries look after
  themselves: one whose file has been deleted, moved, or renamed is dropped the
  next time the File menu opens, and one that no longer loads is dropped when
  you pick it. Below the files, past a separator, **Clear Recent File List**
  forgets the lot; it only empties the list, never touching the projects
  themselves. The submenu is greyed out while the list is empty
- **File → Import Image…** loads native C64 artwork into the current canvas.
  Hires canvases take Art Studio, Interpaint, Image System, and Doodle images;
  multicolor canvases take Vidcom 64, Koala Painter, Artist 64, Advanced Art
  Studio, and Blazing Paddles. The format is recognized from the file itself
  (load address and size; no particular extension needed). ALBERT's own
  chooser
  previews the highlighted file as you browse, naming the format or saying why
  it can't load. On a multi-screen canvas, pick the **target screen** beside
  the preview; through the system chooser, which previews nothing, it is
  asked for once you have
  picked the file. The image replaces that screen's bitmap pixels as one undoable
  edit, together with the colors the file stores: a multicolor image's
  background, and Advanced Art Studio's border, become the document's. On a
  single-screen canvas that is all there is to it, since the image replaces
  every cell those colors govern. On a **multi-screen** canvas only the first
  image you import sets them: the screens an import does not cover keep the
  artwork you drew against the colors already there, so later imports leave
  those alone and the arriving pixels are resolved against them instead, the
  extra colors merging into the closest one each cell can keep. It is the same
  treatment a selection copied from an image with a different background gets
  when you paste it, and it means an import never leaves clashes behind on the
  screens it did not touch. A screen showing a single flat color counts as one
  you have not drawn on, so you can undo an import and try another until the
  artwork settles. That first import also carries its background across those
  screens, so a screen you have not drawn on comes out blank in the new
  background instead of painted in the old one, which would have cost every
  cell there one of its three free colors before you started. On a
  canvas with side-border sprites the strips keep their artwork, but their
  background pixels - the transparent ones, which the side borders share with
  the bitmap - take the new background along with it, so nothing there is left
  painting the old color by hand. The hires image's rightmost 8-pixel column,
  covered by the right border's sprites on the C64, is dropped. Importing into a project you haven't
  saved yet also names it after the image: the window title shows the name
  and Save As proposes it, until a save or open gives the project a real
  file name
- **File → Import Sprites…** loads a sprite file (PRG data or Pixcen's PMAP,
  the same format either way) into the canvas's sprite strips (the entry is
  available on sprite layouts only). With side borders the file holds up to 40
  sprites, four per 21-line sprite row: the left strip's two columns, then the
  right's, row by row from the top. With top/bottom borders it holds up to 32:
  the bottom border's 8 sprites per 21-line row first, then the top's, each
  border's columns hugging its aligned edge. The import replaces the strips
  wholesale as one undoable edit (sprites the file doesn't fill come back
  empty) and, through ALBERT's own file chooser, shows the decoded sheet in
  the dialog as you browse, rendered
  with the canvas's own colors. **Sprite attributes** (beside that preview,
  or in a dialog of its own once the system chooser has closed) picks what each
  sprite's stored attribute byte contributes: **Sprite Pad** (the Pixcen
  convention too) takes the sprite's color from it; **ALBERT**, offered on
  top/bottom canvases, additionally reads the sprite's *position*, placing
  it in the strip column the byte encodes (of the 14 sprite columns spanning
  the border, counted under its current alignment) instead of packing the
  file's sprites edge-to-edge, with the preview following; **Ignore** gives
  every sprite the primary pen color. A 42-line sprite is stored as two
  21-line sprites, each with a color of its own, but the C64 shows a single
  color down all 42 lines: the import takes the color of the *first* of the
  two, the upper one, and draws both halves in it, ignoring whatever color
  the second one stored. So when you prepare a sheet, give a pair's two
  halves the same color and you get back exactly what you stored; give them
  different colors and the upper one wins. That applies to the side borders'
  paired sprites as much as to a top or bottom border, and the sheet in the
  dialog previews the colors the import will land, so what you browse is what
  you get. An import therefore always arrives displayable. The one thing it
  will not fix for you is a border holding more than 8 sprites, which keeps
  its red frames until you reduce it yourself
- **File → Import Reference Image…** overlays an ordinary image (PNG, JPEG,
  BMP; any format Qt reads) on the canvas as a tracing aid. The reference
  layer draws over the artwork and under the grids, and is never part of the
  document: it is free of the C64 palette and clash rules, its alpha channel
  is respected (transparent areas show the artwork through), and drawing
  ignores it entirely. An image that isn't the canvas's on-screen size
  (multicolor's double-wide pixels mean twice the colormap width) asks how
  to scale: **Stretch to Fit** fills the whole canvas, **Keep Aspect Ratio**
  fits the image inside it, centered, with the leftover area empty. The
  scaling keeps hard pixel edges unless **Smooth Scaling for Imported
  Images** (Edit → Settings) is on. Importing switches the layer on; **View → Show Reference Layer** toggles
  it thereafter, and **View → Reference Layer Opacity…** sets how strongly
  it shows. The reference lives with the open document but is not saved in
  the `.alb` file; a new or opened project starts without one
- **File → Convert Image…** (Ctrl+P) turns an ordinary image into C64 artwork: pick the
  dither (none, error diffusion, ordered) and how colors are matched (Euclidean or
  weighted distance), adjust brightness with per-channel curves against a live
  histogram, and preview the result before applying. The conversion dithers
  against all 16 colors first and then resolves the color clashes that leaves,
  so gradients keep the mix of colors the dither chose for them. The
  conversion runs at the canvas's on-screen size (multicolor's
  double-wide pixels mean twice the colormap width): an image of exactly that size
  converts 1:1, and any other size asks how to scale: **Stretch to Fit** fills
  the whole canvas, **Keep Aspect Ratio** fits the image inside it, centered, the
  leftover margins black (they convert like any other pixels, typically to the
  background). That scaling keeps hard pixel edges unless **Smooth Scaling for
  Imported Images** (Edit → Settings) is on; worth turning on for a
  photographic source, where the softer input usually dithers better.
  The dialog carries the same color slots the canvas has, the
  ones for its mode and layout, set the same way (left-click assigns the primary
  color, right-click the secondary); because the conversion picks colors *within*
  them: a sprite gets its border's shared colors plus one free color of its own,
  so changing a slot changes the result, and the preview follows. A canvas with
  no slot of its own, such as hires across more than one screen, shows neither
  the slots nor the palette bar they are picked from. On a
  top/bottom-borders canvas the dialog also offers each border's **sprite
  alignment**, for the same reason: it moves the sprite boundaries the conversion
  picks colors within. Applying it replaces the canvas, the shared colors and
  those alignments as one undoable edit, and adopts the palette variant you
  converted against so the canvas matches the preview. As with **Import
  Image…**, converting into a project you haven't saved yet names it after the
  source image: the window title shows the name and Save As proposes it, until
  a save or open gives the project a real file name
- Converting a top/bottom-borders canvas can leave more than 8 sprites holding
  pixels in a border, which the C64 cannot display: those sprites get the red
  frame like any other, whichever sprite-limit policy is set (the limit blocks
  drawing, it never discards a conversion's artwork). Erase or repaint the
  flagged sprites to clear them
- **File → Export to Image As…** (Ctrl+Shift+P) writes the canvas out as an image file.
  When the canvas is a plain bitmap of exactly one or more C64 screens, a
  small dialog first picks the family: the mode's *native* paint-program
  format (**Art Studio**, `.ocp`, for hires; **Koala Painter**, `.koa`, for
  multicolor), which classic C64 software and **Import Image…** read back
  directly, or a *modern image* (PNG and the other formats Qt supports, chosen
  in the save dialog's format list). The dialog starts on the family you last
  picked, so exporting PNGs while working and a native file at the end takes no
  extra clicks. A multi-screen canvas exports one native
  file per screen, numbered from the left into the chosen name (`name-0.koa`,
  `name-1.koa`, …). A native export also needs the canvas clash-free:
  red-flagged cells stop it with a message, and that message offers to sweep
  them away as one undoable edit and carry on with the export (**Color
  clashes**, above); cancelling there writes nothing. The prompt appears before
  the save dialog, so the canvas is settled before you pick a
  destination. When native export cannot apply,
  for a sprite layout, a free-sized canvas, or an active selection, the dialog
  is skipped and the file is written as a modern image. A modern image keeps
  the C64's shape (a multicolor canvas comes out twice as wide, since its
  pixels are double-wide on screen, the extra columns duplicated exactly with
  no blurring) while ignoring the view's zoom, rotation, and the PAL/NTSC pixel
  stretch, and it always exports, clashes and all, showing the canvas exactly
  as it is. With a selection active the entry reads **Export Selection to Image
  As…** and writes only the selected content, a lasso's out-of-shape corners
  left transparent.
  A modern image can take the borders with it: **Include all borders**, the
  checkbox beside the *modern image* choice, writes the whole picture the way
  the C64 shows it, the border frame around the canvas and every sprite border
  in it, instead of the drawable canvas alone. Sprite layouts never see that
  dialog, so they are asked the same question on its own once you choose the
  entry; either way the answer is remembered for next time, and **Save
  Workstages…** shares it. Borders are a
  modern-image option only: the native formats describe a bare bitmap screen
  and have nowhere to put them, a selection export is the selected content and
  no more, and a canvas that is not exactly one C64 screen is drawn without a
  border frame in the first place, so it is not offered there. **Print…** sends
  the canvas image to a printer. Exporting isn't saving; only writing the
  `.alb` clears the modified marker
- **File → Export to Ultimate Device** (Ctrl+E) runs a ready-to-run C64 program on real
  hardware without a file in between: the artwork is sent over your local
  network to an Ultimate 64, or a C64 fitted with a 1541 Ultimate cartridge,
  which loads and runs it on the spot, the quickest way to judge the artwork
  on a real display. Set the device's IP address or hostname and how long
  ALBERT waits for it under **Edit → Settings** (the device's network services
  must be enabled); ALBERT checks the device is reachable first and says so if
  it isn't, so a wrong address fails with a message rather than a long wait.
  A progress dialog covers the send in three steps: a third once the program
  has been compressed, two thirds once the device has answered, and the rest
  once the program is through. The window stays drawn throughout and takes no
  input other than that dialog's Cancel, which stops the send at the next step
  and reports it on the status bar; the dialog's close button and Esc do the
  same. Nothing is left behind on your machine or half-sent to the device. The timeout you set is what bounds each wait, so
  Cancel is there for the times you would rather not wait it out.
  The entry is gated exactly like **Export to PRG File As…** (a single-screen,
  clash-free canvas within the sprite budget) and like an export it never
  touches the modified marker. On macOS the first send asks for local network
  permission; if it was declined, allow ALBERT under **System Settings →
  Privacy & Security → Local Network**
- **File → Export to PRG File As…** (Ctrl+Shift+E) writes the canvas as a ready-to-run C64
  program: load it on real hardware or an emulator and `RUN` it to see the
  artwork, sprites and all, with the display code adapting to PAL and NTSC
  machines by itself. The file is compressed on its way out with the bundled
  Exomizer into a small self-extracting program (should compression ever
  fail, ALBERT says so and keeps the uncompressed program, started with the
  `SYS` address the message names instead of `RUN`). Compressing one screen
  takes a fraction of a second and usually passes unnoticed; on a slow
  machine a progress dialog appears for the wait, and because the compressor
  reports nothing about how far along it is, the bar runs back and forth
  rather than filling up. Closing that dialog, with its close button or Esc,
  abandons the export: the compressor is left to finish the temporary copy it
  works on, nothing is written where you asked, and the status bar says the
  export was cancelled. The entry is available
  while the canvas is exactly one
  C64 screen, every sprite layout is; a bitmap-only canvas must be the
  standard single-screen size, so free-sized and multi-screen canvases can't
  export. The export also needs the canvas clash-free (red-flagged cells or
  sprites stop it with the same message the native image export shows, offering
  to sweep them away and carry on) and, on a top/bottom-borders canvas, each border
  within the 8-sprite budget: red-flagged extra sprites stop the export with a
  message (nothing is written or repainted); erase them or run **Options →
  Border Sprites → Reduce Border Sprites to Budget** first. The sprite data
  embedded in the file carries each sprite's color the way Sprite Pad and
  Pixcen store it; a top/bottom-borders export additionally records each
  sprite's strip column, so re-importing the file with **Import Sprites…** and
  the **ALBERT** attribute setting puts every sprite back where it was. Like
  an image export, this never touches the modified marker
- **File → Save Workstages…** replays the edit history and writes the canvas at
  successive stages as a numbered PNG sequence (`name-000000.png`,
  `name-000001.png`, …, named after the project) into a folder you pick, ready
  for assembling a time-lapse externally. A *workstage* is the picture as it
  stood at one step of its making: the first is the canvas before any of the
  recorded edits (blank, for a project drawn from scratch) then one stage
  per edit, so the count is always one more than the edits recorded. Save
  **All Workstages** or a **Subset** of a chosen size, spread evenly
  (**Uniform**) or leaning early (**Smart**, which collects more stages from
  the start of the history, where the artwork changes most, and fewer from
  the late refinement). The frames render like a modern image export does,
  **Include all borders** and all: you are asked the same question here, it
  remembers the same answer, and a framed sequence shows each stage in the
  border color that was in force at that stage, not in the one the canvas
  carries today, so a color you changed part-way through the drawing changes
  part-way through the time-lapse. The
  sequence always ends on the canvas as it stands: edits you undid are not
  replayed. A progress dialog covers a long sequence, and its Cancel (or Esc, or
  its close button) stops the run where it is: the frames already written stay in
  the folder, and the status bar says how many of them there are

## Help and version information

- **Help → User Manual** (F1) opens this manual in a window of its own, so it
  stays beside the canvas while you work. It is the manual for the version you
  are running, not a copy fetched from the web, so it never describes a feature
  your copy does not have
- **Help → Online User Manual** opens the manual published on the ALBERT website
  in your default web browser. That copy covers the current release, so it can
  describe things your version does not have yet, and it needs an internet
  connection; the built-in manual above is the one that always matches what you
  are running
- **Help → About** identifies the copy in your hands: the version, with any
  pre-release suffix highlighted so a development build is obvious; the two
  people behind ALBERT; the date it was built and the compiler that built it;
  and the version of Qt, the toolkit ALBERT is written with, that it is running
  on. Quote those lines when you report a problem: they say exactly which build
  you saw it in. The website link at the bottom opens in your browser, and
  through December the logo wears a santa hat
- **Help → About Qt** describes Qt itself, which is separate from ALBERT

## What ALBERT remembers

- The grid toggles, the reference layer's opacity, the display pixel aspect,
  the window geometry, the preview
  window's visibility, geometry, stay-on-top, mirror and CRT choices, the Convert
  Image dialog's geometry and its dither choice, the Save
  Workstages dialog's position and reduction method, the zoom wheel direction,
  Bind Zoom to Canvas and Smooth Scaling for Imported Images preferences, the
  file chooser choice, the menu bar's placement on macOS,
  and the Ultimate device's host and
  timeout (Edit → Settings), and the
  folders last used for project open/save, image export, PRG export,
  image-to-convert, image import, sprite import,
  workstage saving, and reference-image import (eight separate last-folders
  that never mix) persist across
  sessions as
  per-user settings; everything document-related (canvas, colors, history) lives
  in the project file instead

## Keyboard shortcuts

A quick reference to the keys you press with your hand on the drawing area. The
menu entries carry shortcuts of their own (Ctrl+S to save, Ctrl+Z to undo, and
so on) and every menu shows them beside the entry, so they are not repeated
here. The sections above describe what these keys do in full.

- **Picking colors**:
  - **1** to **8** set the primary color to the first eight palette colors,
    **Shift+1** to **Shift+8** to the other eight, in the order the palette bar
    shows them. The bar's selection follows either way
  - **Hold C** to see what the *right* button would paint: the brush and fill
    previews swap the primary and secondary colors for as long as the key is
    down. It only predicts; the buttons keep their meaning
- **Choosing a tool.** Exactly one tool is active at any time, and picking the
  one already active changes nothing, so none of these can switch a tool off by
  accident:
  - **B** pen, **E** eraser, **G** fill, **S** shapes, **I** eyedropper,
    **H** pan, **M** rectangle select, **L** lasso select, **Y** move the
    symmetry axes
  - **Hold Alt** while the pen is active to borrow the eyedropper without
    leaving the pen: Alt+click samples the color under the cursor as the
    primary, Alt+right-click as the secondary, and releasing Alt puts you back
    to drawing. The cursor becomes a dropper while it is armed
  - **Hold Space** and drag to pan under any tool without leaving the one you
    are on (the middle button drags the same way), and **hold R** and drag to
    rotate the view around the viewport center
- **Changing the pen width**: `,` or `[` steps it down one pixel, `.` or `]`
  steps it up; hold a key and it repeats, like holding the **-** and **+**
  buttons on the texture strip
- **Z** switches both reference grids to a lighter grey, and back on the next
  press, so a grid line stays findable where the artwork under it is dark. It
  only changes how they look: which grids are shown is still **View → Show
  Reference Grids** and **Show Pixel Grids**, and Shift+Z is that second toggle
- **The arrow keys** move whatever is in front of them:
  - with nothing staged they **pan the view** by exactly one char cell a press
  - with a **floating selection** or **staged shapes selected** they nudge that
    instead, by one canvas pixel, and **Shift+arrows** by one char cell, the
    step that matters when hunting for a clash-free placement
- **Esc** backs out of whatever is in progress. It deselects, abandons a drag
  mid-gesture, discards a floating selection and leaves the canvas underneath
  untouched, and throws the staged shapes away without recording anything,
  asking you to confirm in that last case alone.
  **Enter** is its opposite: it drops a float or commits the stage as one
  undoable edit. **Delete** removes the selected staged shapes, and the key
  above **Tab** (the backtick ` on a US keyboard, the section sign on an Apple
  US/UK one) cycles the selection through them
- **Tab** hides and shows the dashboards
- **Shift means "the variant of what you are doing"**, so what it does depends
  on the tool in hand rather than being one fixed function:
  - with the **pen** or **eraser** it rubber-bands a connecting line from where
    your last stroke ended, previewing it solid until you release
  - creating a **shape**, it constrains the drag to uniform aspect on the
    emulated display (a square, a true circle); on a corner handle it keeps that
    aspect while scaling, and on the rotation pin it snaps to 22.5° steps
  - during an **R+drag** it snaps the view rotation to those same 22.5° steps
  - starting a **selection** drag it adds to what is already selected (Alt
    subtracts, Shift+Alt intersects), and **Shift+click** adds or removes a
    staged shape from the selection
  - with the **arrow keys** it turns the one-pixel nudge into a one-cell nudge
  - with the **number keys** it reaches the upper half of the palette
- **Ctrl** (Cmd on macOS) is the other tool-dependent modifier, and it means two
  things:
  - everywhere geometry is drawn, *align to the canvas, not the screen*. Held
    while a square nib strokes, a shape is dragged out, or a marquee is pulled,
    the geometry follows the canvas axes instead of the screen axes it follows
    by default, which is only visible on a rotated view
  - with the **fill tool** it traces a contour instead of filling, in the
    placement set under **Options → Fill Contour Placement**. Multicolor
    canvases only, and described in full with the fill tool above

