Identifying library referenced errors lesson, signs, redefinitions, previously?

I’m getting a few errors pointing to a library font.h, but I can’t determine the cause, or find a precedence. I have tried compiling the library in codeblocks with GNU GCC without issues.

Errors:
In file included from PS2YouDisplay.ino:4:
C:\Documents and Settings\Ash\My Documents\Arduino\libraries\MatrixDisplay/font.h:3: error: redefinition of ‘const int font_count’
C:\Documents and Settings\Ash\My Documents\Arduino\libraries\MatrixDisplay/font.h:3: error: ‘const int font_count’ previously defined here
C:\Documents and Settings\Ash\My Documents\Arduino\libraries\MatrixDisplay/font.h:4: error: redefinition of ‘unsigned char myfont [92][5]’
C:\Documents and Settings\Ash\My Documents\Arduino\libraries\MatrixDisplay/font.h:4: error: ‘unsigned char myfont [92][5]’ previously defined here

This is my font.h code:

#include <avr/pgmspace.h>

const int font_count = 92;
unsigned char PROGMEM myfont[92][5] = {
{0x00,0x00,0x00,0x00,0x00}, // (0) space

{0xbe,0xc1,0xc1,0xc1,0xbe}, // (1) 0
{0x91,0xa1,0xff,0x81,0x81}, // (2) 1
{0xa1,0xc3,0xc5,0xc9,0xb1}, // (3) 2
{0xc2,0xc1,0xd1,0xd9,0xe6}, // (4) 3
{0x98,0xa8,0xc8,0x88,0xff}, // (5) 4
{0xfa,0xd1,0xd1,0xd1,0xce}, // (6) 5
{0xbe,0xc9,0xc9,0xc9,0xa6}, // (7) 6
{0xc3,0xc4,0xc8,0xd0,0xe0}, // (8) 7
{0xb6,0xc9,0xc9,0xc9,0xb6}, // (9) 8
{0xb2,0xc9,0xc9,0xc9,0xbe}, // (10) 9

{0x02,0x15,0x15,0x15,0x0f}, // (11) a
{0x7f,0x11,0x11,0x11,0xe},  // (12) b
{0xe,0x11,0x11,0x11,0x0},   // (13) c
{0xe,0x11,0x11,0x11,0x7f},  // (14) d
{0xe,0x15,0x15,0x15,0xc},   // (15) e
{0x8,0x8,0x3f,0x48,0x28},   // (16) f
{0x8,0x15,0x15,0x15,0xe},   // (17) g
{0xff,0x88,0x90,0x90,0x8f}, // (18) h
{0x00,0x00,0x5f,0x00,0x00}, // (19) i
{0x2,0x1,0x1,0x5e,0x0},     // (20) j
{0xff,0x84,0x8c,0x92,0x81}, // (21) k
{0x00,0x00,0xff,0x00,0x00}, // (22) l
{0xf,0x10,0x8,0x10,0xf},    // (23) m
{0x1f,0x8,0x10,0x10,0xf},   // (24) n
{0xe,0x11,0x11,0x11,0xe},   // (25) o
{0x1f,0x14,0x14,0x14,0x08}, // (26) p
{0x0c,0x12,0x12,0x1f,0x1},  // (27) q
{0x1f,0x88,0x90,0x90,0x90}, // (28) r
{0x9,0x15,0x15,0x15,0x2},   // (29) s
{0x10,0x10,0x7f,0x10,0x10}, // (30) t
{0x1e,0x81,0x81,0x82,0x1f}, // (31) u
{0x1c,0x2,0x1,0x2,0x1c},    // (32) v
{0x1e,0x1,0x6,0x1,0x1e},    // (33) w
{0x11,0xa,0x4,0xa,0x11},    // (34) x
{0x18,0x5,0x5,0x5,0x1e},    // (35) y
{0x91,0x93,0x95,0x99,0x91}, // (36) z

{0x3f,0x48,0x48,0x48,0x3f}, // (37) A
{0xff,0xc9,0xc9,0xc9,0xb6}, // (38) B
{0xbe,0xc1,0xc1,0xc1,0xa2}, // (39) C
{0xff,0xc1,0xc1,0xa2,0x9c}, // (40) D
{0xff,0xc9,0xc9,0xc9,0xc1}, // (41) E
{0xff,0xc8,0xc8,0xc8,0xc0}, // (42) F
{0xbe,0xc1,0xcd,0xc9,0xae}, // (43) G
{0xff,0x88,0x88,0x88,0xff}, // (44) H
{0xc1,0xc1,0xff,0xc1,0xc1}, // (45) I
{0x86,0xc1,0xc1,0xfe,0xc0}, // (46) J
{0xff,0x88,0x94,0xa2,0xc1}, // (47) K
{0xff,0x81,0x81,0x81,0x81}, // (48) L
{0xff,0xa0,0x90,0xa0,0xff}, // (49) M
{0xff,0xa0,0x90,0x88,0xff}, // (50) N
{0xbe,0xc1,0xc1,0xc1,0xbe}, // (51) O
{0xff,0xc8,0xc8,0xc8,0xb0}, // (52) P
{0xbe,0xc1,0xc5,0xc3,0xbf}, // (53) Q
{0xff,0xc8,0xc8,0xc8,0xb7}, // (54) R
{0xb2,0xc9,0xc9,0xc9,0xa6}, // (55) S
{0xc0,0xc0,0xff,0xc0,0xc0}, // (56) T
{0xfe,0x81,0x81,0x81,0xfe}, // (57) U
{0xfc,0x82,0x81,0x82,0xfc}, // (58) V
{0xff,0x82,0x84,0x82,0xff}, // (59) W
{0xe3,0x94,0x88,0x94,0xe3}, // (60) X
{0xe0,0x90,0x8f,0x90,0xe0}, // (61) Y
{0xc3,0xc5,0xc9,0xd1,0xe1}, // (62) Z

{0x00,0x00,0xfd,0x00,0x00}, // (63) !
{0xbe,0xc9,0xd5,0xc9,0xba}, // (64) @
{0x94,0xff,0x94,0xff,0x94}, // (65) #
{0x90,0xaa,0xff,0xaa,0x84}, // (66) $
{0xe2,0xe4,0x88,0x93,0xa3}, // (67) %
{0x10,0x20,0x40,0x20,0x10}, // (68) ^
{0x36,0x49,0x35,0x2,0x5},   // (69) &
{0xaa,0x9c,0x6b,0x9c,0xaa}, // (70) *
{0x00,0x1c,0x22,0x41,0x00}, // (71) (
{0x00,0x41,0x22,0x1c,0x00}, // (72) )
{0x00,0x85,0x86,0x00,0x00}, // (73) ,
{0x88,0x88,0x88,0x88,0x88}, // (74) -
{0x00,0x83,0x83,0x00,0x00}, // (75) .
{0xa0,0xc0,0xc5,0xc8,0xb0}, // (76) ?
{0x00,0xc1,0xa2,0x94,0x88}, // (77) >
{0x88,0x94,0xa2,0xc1,0x00}, // (78) <
{0x82,0x84,0x88,0x90,0xa0}, // (79) /
{0xa0,0x90,0x88,0x84,0x82}, // (80) \
{0x00,0x00,0xff,0x00,0x00}, // (81) |
{0x00,0x00,0xff,0x00,0x00}, // (81) |
{0x00,0xff,0xc1,0xc1,0x00}, // (82) [
{0x00,0xc1,0xc1,0xff,0x00}, // (83) ]
{0x1,0x1,0x1,0x1,0x1},      // (84) _
{0x14,0x14,0x14,0x14,0x14}, // (85) =
{0x8,0x8,0x3E,0x8,0x8},     // (86)  +
{0x0,0x12,0x0,0x0,0x0},     // (87) :
{0x0,0x0,0x60,0x0,0x0},     // (88) '
{0x0,0x60,0x0,0x60,0x0},    // (89) "
{0x41,0x41,0x36,0x8,0x0},   // (90) }
{0x0,0x8,0x36,0x41,0x41},   // (91) {

};

Did you mean to also post PS2YouDisplay.ino ? (hint, hint)

Project code:

#include <font.h>
#include <MatrixDisplay.h>

/*
  PS/2/You -- Takes text input from a PS/2 keyboard and displays it on 
  cascaded Sure 0832 LED matrix panels.
  Thanks to the authors of the PS2Keyboard (Ext2) and MatrixDisplay libraries
  on which this project is based.
  See the README.txt file for instructions on controlling the display output 
  with the keyboard and editing font glyphs.
  This code is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.
  This code is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include <string.h>
#include "MatrixDisplay.h"
#include "DisplayToolbox.h"
#include "font.h"
#include "PS2Keyboard.h"

const int numLines = 6;        // Max number of lines
const int displayTime = 1500;  // Length of time in milliseconds to display each line
const int gapTime = 10;        // Time gap between lines
const int maxLineLength = 100; // Maximum length of a line in characters

String textLines[numLines];     // Array of text lines

int textLength;          // Holds current line length in pixels
int strLength;           // Holds current line length in characters
int currentLine = 0;     // Index of current line

int mode = 2;            // Determines whether in input (1) or output (2) mode

char defaultText[numLines][30] = {{"Hello World!"},{"Welcome to PS/2/You"},{"Start typing..."}};

// Character lookup string -- used to map the characters from the keyboard onto the font data array
// (This should probably be moved to program memory in some form in the future)
String charLookup  = " 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!@#$%^&*(),-.?></\\|[]_=+:'\"{}";

// Memory test
extern int __bss_end;
extern int *__brkval;

/* DISPLAY LIBRARY SETUP */

// Parameters for Matrix Display initialization:
// Number of displays = 3
// Data pin = 10 
// WR pin == 11
// Shadow buffer = true

// Macro to make it the initDisplay function a little easier to understand
#define setMaster(dispNum, CSPin) initDisplay(dispNum,CSPin,true)
#define setSlave(dispNum, CSPin) initDisplay(dispNum,CSPin,false)

// Initialize matrix
MatrixDisplay disp(3,11,10, true);
DisplayToolbox toolbox(&disp);

// Prepare boundaries
uint8_t X_MAX = 0;
uint8_t Y_MAX = 0;

/* KEYBOARD SETUP */

#define KBD_CLK_PIN  3
#define KBD_DATA_PIN 7

#define is_printable(c) (!(c&0x80))   

PS2Keyboard keyboard;

void setup() { 
 
  //Serial.begin(9600);  

  for(int i=0; i<numLines; i++){
    textLines[i] = defaultText[i];
    //Serial.println(defaultText[i]);
  }
  // Initialize the keyboard class
  keyboard.begin(KBD_DATA_PIN); 
  
  // Fetch display bounds 
  X_MAX = disp.getDisplayCount() * (disp.getDisplayWidth()-1)+3;
  Y_MAX = disp.getDisplayHeight()-1;
 
  // Prepare displays
  disp.setMaster(0,4);
  disp.setSlave(1,5);
  disp.setSlave(2,6);
}

void loop() {
  
  while (keyboard.available()) {
    
    // read the key
    byte c = keyboard.read();
    
    if (mode == 2){
      mode = 1; // If any keyboard data is entered, switch to input mode
      prevLine(); 
      if(c != PS2_KC_ENTER){ // Ditch the first char entered on going into input mode
        return; 
      } 
    }
    
    //Serial.println(c);
   
    if (c == PS2_KC_ENTER) { // Pressing enter goes into output mode
        mode = 2;
    } else if (c == PS2_KC_ESC) { // ESC erases current line
      textLines[currentLine] = "";
    } else if (c == PS2_KC_UP)  { // Up arrow goes to previous line (or loops to last line)
      prevLine();
    } else if (c == PS2_KC_DOWN) { // Down arrow goes to next line
      nextLine();
    } else if (c == PS2_KC_BKSP) { // Truncate the current line by one character
      String thisLine = textLines[currentLine];
      textLines[currentLine] = thisLine.substring(0,(thisLine.length()-1));
    } else if (strLength < maxLineLength && is_printable(c)){  // Otherwise add the character to the line, if the line is not too long
      textLines[currentLine] += char(c);
      if(get_free_memory() < 80){
        low_memory_alert();
      }
    }
  }
  strLength = textLines[currentLine].length(); // Number of characters in the string
  textLength = (strLength*6); // Width of string in pixels
  
  // Convert the String into a char array
  char* text; 
  char textMem[maxLineLength];
  for(int i=0;i<maxLineLength;i++){
    textMem[i]=textLines[currentLine][i];
  }
  text = textMem;
 
  if(mode == 2){ // Output mode
     if(strLength > 1){
       if(textLength < (X_MAX +1)){
         fixedText(text);
         delay(displayTime);
         disp.clear(); 
         disp.syncDisplays();
         delay(gapTime); 
       }else{
         scrollText(text); 
         delay(gapTime);
       }
     }
     nextLine();
  }else{ // Input mode
    if(textLength > X_MAX){ // If the line is longer than the display, trim off the beginning
      int displayLengthChars = (X_MAX/6)+1;             
      char out[displayLengthChars];                     
      int startChar = (strLength - displayLengthChars);  
      for(int i = 0; i < displayLengthChars; i++){
        startChar++;
        out[i] = text[startChar];
      } 
      fixedText(out);
    }else{
      fixedText(text); 
    }
  }
}

void nextLine(){
   if(currentLine < (numLines -1)){
      currentLine++; 
   }else{
     currentLine = 0;
   }    
}

void prevLine(){
  if(currentLine > 0){
     currentLine--; 
  } else {
     currentLine = (numLines -1);
  }
}

// Scroll a line of text across the display

/* This is a fairly inefficient function. It uses drawString() to 
redraw repeatedly as it moves. Not a problem in this case, but if 
faster scrolling was needed it should probably be rewritten to use 
disp.shiftLeft() instead */

void scrollText(char* text){
  int y=1;
  int endPos = 0 - textLength;
  int loopCount = 0;
  for(int Xpos = X_MAX; Xpos > endPos; Xpos--){
    if(loopCount > 10){ // Check for incoming keyboard data every 10 loops
     loopCount = 0;
      if(keyboard.available()){
        return;
      } 
    }
    loopCount++;
    disp.clear();
    drawString(Xpos,y,text); 
    disp.syncDisplays(); 
  }
}

// Write a line of static (non-scrolling) text to the display
void fixedText(char* text){
  int y = 1;
  int x = 0;
  disp.clear();
  drawString(x,y,text);
  disp.syncDisplays(); 
}


// Output a string to the display
void drawString(int x, uint8_t y, char* c){
  for(char i=0; i< strLength; i++){
    drawChar(x, y, c[i]);
    x+=6; // Width of each glyph
  }
}

// Output a single character to the display
void drawChar(int x, int y, char c){
  int dots;
  
  c = charLookup.indexOf(c);
  
  for (char col=0; col< 5; col++) {
    if((x+col+1)>0 && x < X_MAX){ // dont write to the display buffer if the location is out of range
      dots = pgm_read_byte_near(&myfont[c][col]);
      for (char row=0; row < 7; row++) {
        if (dots & (64>>row))   	     // only 7 rows.
          toolbox.setPixel(x+col, y+row, 1);
        else 
          toolbox.setPixel(x+col, y+row, 0);
      }
    }
  }
}

// Warn if we're running out of RAM
void low_memory_alert(){
  for(int i=0; i < 3; i++){
    int y = 1;
    int x = 0;
    disp.clear();
    drawString(x,y,"   MEMORY LOW!  ");
    disp.syncDisplays();
    delay(500);
    disp.clear();
    disp.syncDisplays();
    delay(500);
    disp.clear();
  }
}

// Memory check
int get_free_memory(){
  int free_memory;
  if((int)__brkval == 0)
    free_memory = ((int)&free_memory) - ((int)&__bss_end);
  else
    free_memory = ((int)&free_memory) - ((int)__brkval);
    Serial.println(free_memory);
  return free_memory;
}

Is there some reason you feel compelled to include font.h twice?