[mirror_edk2.git] / Tools / Python / Fd.py

#!/usr/bin/env python

# An EDK II Build System Framework Database Utility maintains FrameworkDatabase.db 
#  settings in an EDK II Workspace.

import wx, os, sys, copy
from EdkIIWorkspace import *

class FrameworkDatabaseModel(EdkIIWorkspace):
  def __init__(self):
    self.WorkspaceStatus = EdkIIWorkspace.__init__(self)
    self.Database = {}    
    self.OriginalDatabase = {}
        
  def AddFile (self, DirName, FileName, FileType, Enabled):
    if DirName != '':
      FileName = os.path.join(DirName,FileName)
    if FileType == 'Package':
      Header  = self.XmlParseFileSection (FileName, 'SpdHeader')
      Name    = XmlElement (Header, '/SpdHeader/PackageName')
      Version = XmlElement (Header, '/SpdHeader/Version')
    elif FileType == 'Platform':
      Header  = self.XmlParseFileSection (FileName, 'PlatformHeader')
      Name    = XmlElement (Header, '/PlatformHeader/PlatformName')
      Version = XmlElement (Header, '/PlatformHeader/Version')
    else:
      return
    FileName = FileName.replace('\\','/')
    if Name == '' and Version == '':
      ValidType = 'Invalid'
      OtherType = 'Valid'
      UiName    = FileName
    else:
      ValidType = 'Valid'
      OtherType = 'Invalid'
      UiName    = Name + ' [' + Version + ']'
    self.Database[FileType][OtherType]['PossibleSettings'].pop(FileName, None)
    self.Database[FileType][OtherType]['EnabledSettings'].pop(FileName, None)
    self.Database[FileType][ValidType]['PossibleSettings'][FileName] = UiName
    if Enabled:
      self.Database[FileType][ValidType]['EnabledSettings'][FileName] = UiName
    return

  def NewModel(self):
    self.Database['Platform'] = {'Valid': {'PossibleSettings':{}, 'EnabledSettings':{}},'Invalid': {'PossibleSettings':{}, 'EnabledSettings':{}}}
    self.Database['Package']  = {'Valid': {'PossibleSettings':{}, 'EnabledSettings':{}},'Invalid': {'PossibleSettings':{}, 'EnabledSettings':{}}}

  def RevertModel(self):
    self.Database = copy.deepcopy(self.OriginalDatabase)
    
  def RescanModel(self):
    self.NewModel()
    self.Fd = self.XmlParseFile ('Tools/Conf/FrameworkDatabase.db')
    PackageList = XmlList (self.Fd, '/FrameworkDatabase/PackageList/Filename')
    for File in PackageList:
      SpdFileName = XmlElementData(File)
      self.AddFile ('', SpdFileName, 'Package', True)
    PlatformList = XmlList (self.Fd, '/FrameworkDatabase/PlatformList/Filename')
    for File in PlatformList:
      FpdFileName = XmlElementData(File)
      self.AddFile ('', FpdFileName, 'Platform', True)
    self.OriginalDatabase = copy.deepcopy(self.Database)

  def RefreshModel(self):
    Temp = copy.deepcopy(self.Database)
    for FileType in ['Package','Platform']:
      for Valid in ['Valid','Invalid']:
        for Item in Temp[FileType][Valid]['PossibleSettings']:
          self.AddFile('',Item, FileType, Item in Temp[FileType][Valid]['EnabledSettings'])
    return True

  def ModelModified(self):
    if self.Database['Package']['Valid']['EnabledSettings'] != self.OriginalDatabase['Package']['Valid']['EnabledSettings']:
      return True
    if self.Database['Package']['Invalid']['EnabledSettings'] != self.OriginalDatabase['Package']['Invalid']['EnabledSettings']:
      return True
    if self.Database['Platform']['Valid']['EnabledSettings'] != self.OriginalDatabase['Platform']['Valid']['EnabledSettings']:
      return True
    if self.Database['Platform']['Invalid']['EnabledSettings'] != self.OriginalDatabase['Platform']['Invalid']['EnabledSettings']:
      return True
    return False
    
  def SaveModel(self, Filename='Tools/Conf/FrameworkDatabase.db'):
    EnabledList =  self.Database['Package']['Valid']['EnabledSettings'].keys() 
    EnabledList += self.Database['Package']['Invalid']['EnabledSettings'].keys() 
    PackageList =  XmlList (self.Fd, '/FrameworkDatabase/PackageList/Filename')
    for File in PackageList:
      SpdFileName = XmlElementData(File)
      if SpdFileName in EnabledList:
        EnabledList.remove(SpdFileName)
        continue
      XmlRemoveElement(File)
      
    ParentNode = XmlList (self.Fd, '/FrameworkDatabase/PackageList')[0]
    for SpdFileName in EnabledList:
      XmlAppendChildElement(ParentNode, u'Filename', SpdFileName)

    EnabledList =  self.Database['Platform']['Valid']['EnabledSettings'].keys() 
    EnabledList += self.Database['Platform']['Invalid']['EnabledSettings'].keys() 
    PlatformList = XmlList (self.Fd, '/FrameworkDatabase/PlatformList/Filename')
    for File in PlatformList:
      FpdFileName = XmlElementData(File)
      if FpdFileName in EnabledList:
        EnabledList.remove(FpdFileName)
        continue
      XmlRemoveElement(File)
      
    ParentNode = XmlList (self.Fd, '/FrameworkDatabase/PlatformList')[0]
    for FpdFileName in EnabledList:
      XmlAppendChildElement(ParentNode, u'Filename', FpdFileName)

    self.XmlSaveFile (self.Fd, Filename)
    self.OriginalDatabase = copy.deepcopy(self.Database)

  def CloseModel(self):
    pass
    
class Frame(wx.Frame):
  def __init__(self):
    wx.Frame.__init__(self,None,-1,'EDK II Build System Framework Database Utility')
    panel = wx.Panel(self, style=wx.SUNKEN_BORDER | wx.TAB_TRAVERSAL)
    wx.HelpProvider_Set(wx.SimpleHelpProvider())

    self.Model = FrameworkDatabaseModel()

    #
    #  Help text
    #
    PackagesHelpText = ( 
    "The set of packages that are active in the current WORKSPACE."
    )

    PlatformsHelpText = ( 
    "The set of platforms that are active in the current WORKSPACE."
    )

    InvalidPackagesHelpText = ( 
    "The set of packages that are in Framework Database, but not in the current WORKSPACE."
    )

    InvalidPlatformsHelpText = ( 
    "The set of platforms that are in Framework Database, but not in the current WORKSPACE."
    )
    
    #
    # Status Bar
    #
    self.StatusBar = self.CreateStatusBar()    
    
    #
    # Build Menus
    #    
    MenuBar = wx.MenuBar()
    
    FileMenu = wx.Menu()
    NewMenuItem         = FileMenu.Append(-1, "&New\tCtrl+N",            "New FrameworkDatabase.db")
    SaveMenuItem        = FileMenu.Append(-1, "&Save\tCtrl+S",           "Save FramdworkDatabase.db")
    SaveAsMenuItem      = FileMenu.Append(-1, "Save &As...",             "Save FrameworkDatabase.db as...")
    RevertMenuItem      = FileMenu.Append(-1, "&Revert",                 "Revert to the original FrameworkDatabase.db")
    ScanMenuItem        = FileMenu.Append(-1, "Scan &WORKSPACE\tCtrl+W", "Scan WORKSPACE for additional packages and platforms")
    ScanAndSyncMenuItem = FileMenu.Append(-1, "Scan &WORKSPACE and Sync\tCtrl+W", "Scan WORKSPACE for additional packages and platforms and sync FramdworkDatabase.db")
    ExitMenuItem        = FileMenu.Append(-1, "E&xit\tAlt+F4",           "Exit Framework Database Tool")
    MenuBar.Append(FileMenu, "&File")
    self.Bind(wx.EVT_MENU, self.OnSaveClick,        SaveMenuItem)
    self.Bind(wx.EVT_MENU, self.OnSaveAsClick,      SaveAsMenuItem)
    self.Bind(wx.EVT_MENU, self.OnRevertClick,      RevertMenuItem)
    self.Bind(wx.EVT_MENU, self.OnScanClick,        ScanMenuItem)
    self.Bind(wx.EVT_MENU, self.OnScanAndSyncClick, ScanAndSyncMenuItem)
    self.Bind(wx.EVT_MENU, self.OnExitClick,        ExitMenuItem)

    EditMenu = wx.Menu()
    SelectAllPlatformsMenuItem = EditMenu.Append (-1, "Select All Platforms", "Select all platforms")
    ClearAllPlatformsMenuItem  = EditMenu.Append (-1, "Clear All Platforms",  "Clear all platforms")
    SelectAllPackagesMenuItem  = EditMenu.Append (-1, "Select All Packages",  "Select all packages")
    ClearAllPackagesMenuItem   = EditMenu.Append (-1, "Clear All Packages",   "Clear all packages")
    SelectAllInvalidPlatformsMenuItem = EditMenu.Append (-1, "Select All Invalid Platforms", "Select all invalid platforms")
    ClearAllInvalidPlatformsMenuItem  = EditMenu.Append (-1, "Clear All Invalid Platforms",  "Clear all invalid platforms")
    SelectAllInvalidPackagesMenuItem  = EditMenu.Append (-1, "Select All Invalid Packages",  "Select all invalid packages")
    ClearAllInvalidPackagesMenuItem   = EditMenu.Append (-1, "Clear All Invalid Packages",   "Clear all invalid packages")
    MenuBar.Append(EditMenu, "&Edit")
    self.Bind(wx.EVT_MENU, self.OnSelectAllPlatformsClick, SelectAllPlatformsMenuItem)
    self.Bind(wx.EVT_MENU, self.OnClearAllPlatformsClick,  ClearAllPlatformsMenuItem)
    self.Bind(wx.EVT_MENU, self.OnSelectAllPackagesClick,  SelectAllPackagesMenuItem)
    self.Bind(wx.EVT_MENU, self.OnClearAllPackagesClick,   ClearAllPackagesMenuItem)
    self.Bind(wx.EVT_MENU, self.OnSelectAllInvalidPlatformsClick, SelectAllInvalidPlatformsMenuItem)
    self.Bind(wx.EVT_MENU, self.OnClearAllInvalidPlatformsClick,  ClearAllInvalidPlatformsMenuItem)
    self.Bind(wx.EVT_MENU, self.OnSelectAllInvalidPackagesClick,  SelectAllInvalidPackagesMenuItem)
    self.Bind(wx.EVT_MENU, self.OnClearAllInvalidPackagesClick,   ClearAllInvalidPackagesMenuItem)
    
    ViewMenu = wx.Menu()
    RefreshMenuItem = ViewMenu.Append (-1, "&Refresh\tF5", "Rescan FrameworkDatabase.db")
    ShowToolBarMenuItem = ViewMenu.AppendCheckItem (-1, "Show &Toolbar", "Shows or hides the toolbar")
    ShowToolBarMenuItem.Check(True)
    MenuBar.Append(ViewMenu, "&View")
    self.Bind(wx.EVT_MENU, self.OnViewRefreshClick, RefreshMenuItem)
    self.Bind(wx.EVT_MENU, self.OnShowToolBarClick, ShowToolBarMenuItem)
    
    HelpMenu = wx.Menu()
    AboutMenuItem = HelpMenu.Append (-1, "&About...", "About")
    MenuBar.Append(HelpMenu, "&Help")
    self.Bind(wx.EVT_MENU, self.OnAboutClick, AboutMenuItem)
    
    self.SetMenuBar (MenuBar)

    #
    # Build Toolbar
    #    
    self.ShowToolBar = False
    self.OnShowToolBarClick(self)

    #
    # Target, ToolChain, and Arch Check List Boxes
    #
    PackagesLabel = wx.StaticText(panel, -1, 'Packages')
    PackagesLabel.SetFont(wx.Font(12, wx.FONTFAMILY_DEFAULT, wx.NORMAL, wx.FONTWEIGHT_BOLD))
    PackagesLabel.SetHelpText(PackagesHelpText)

    PlatformsLabel = wx.StaticText(panel, -1, 'Platforms')
    PlatformsLabel.SetFont(wx.Font(12, wx.FONTFAMILY_DEFAULT, wx.NORMAL, wx.FONTWEIGHT_BOLD))
    PlatformsLabel.SetHelpText(PlatformsHelpText)
    
    #
    # Buttons
    #
    self.SelectAllPackagesButton  = wx.Button(panel, -1, 'Select All')
    self.ClearAllPackagesButton   = wx.Button(panel, -1, 'Clear All')
    self.SelectAllPackagesButton.Bind (wx.EVT_BUTTON, self.OnSelectAllPackagesClick)
    self.ClearAllPackagesButton.Bind  (wx.EVT_BUTTON, self.OnClearAllPackagesClick)
    
    self.PackagesCheckListBox = wx.CheckListBox(panel, -1)
    self.PackagesCheckListBox.Bind(wx.EVT_CHECKLISTBOX, self.OnPackagesCheckListClick)
    self.PackagesCheckListBox.Bind(wx.EVT_SET_FOCUS, self.OnPackagesSetFocus)
    self.PackagesCheckListBox.Bind(wx.EVT_KILL_FOCUS, self.OnPackagesKillFocus)
    self.PackagesCheckListBox.SetHelpText(PackagesHelpText)

    
    self.SelectAllPlatformsButton = wx.Button(panel, -1, 'Select All')
    self.ClearAllPlatformsButton  = wx.Button(panel, -1, 'Clear All')
    self.SelectAllPlatformsButton.Bind(wx.EVT_BUTTON, self.OnSelectAllPlatformsClick)
    self.ClearAllPlatformsButton.Bind (wx.EVT_BUTTON, self.OnClearAllPlatformsClick)

    self.PlatformsCheckListBox = wx.CheckListBox(panel, -1)
    self.PlatformsCheckListBox.Bind(wx.EVT_CHECKLISTBOX, self.OnPlatformsCheckListClick)
    self.PlatformsCheckListBox.Bind(wx.EVT_SET_FOCUS, self.OnPlatformsSetFocus)
    self.PlatformsCheckListBox.Bind(wx.EVT_KILL_FOCUS, self.OnPlatformsKillFocus)
    self.PlatformsCheckListBox.SetHelpText(PlatformsHelpText)

    InvalidPackagesLabel = wx.StaticText(panel, -1, 'Invalid Packages')
    InvalidPackagesLabel.SetFont(wx.Font(12, wx.FONTFAMILY_DEFAULT, wx.NORMAL, wx.FONTWEIGHT_BOLD))
    InvalidPackagesLabel.SetHelpText(InvalidPackagesHelpText)

    InvalidPlatformsLabel = wx.StaticText(panel, -1, 'Invalid Platforms')
    InvalidPlatformsLabel.SetFont(wx.Font(12, wx.FONTFAMILY_DEFAULT, wx.NORMAL, wx.FONTWEIGHT_BOLD))
    InvalidPlatformsLabel.SetHelpText(InvalidPlatformsHelpText)
    
    self.SelectAllInvalidPackagesButton  = wx.Button(panel, -1, 'Select All')
    self.ClearAllInvalidPackagesButton   = wx.Button(panel, -1, 'Clear All')
    self.SelectAllInvalidPackagesButton.Bind (wx.EVT_BUTTON, self.OnSelectAllInvalidPackagesClick)
    self.ClearAllInvalidPackagesButton.Bind  (wx.EVT_BUTTON, self.OnClearAllInvalidPackagesClick)

    self.InvalidPackagesCheckListBox = wx.CheckListBox(panel, -1)
    self.InvalidPackagesCheckListBox.Bind(wx.EVT_CHECKLISTBOX, self.OnInvalidPackagesCheckListClick)
    self.InvalidPackagesCheckListBox.Bind(wx.EVT_SET_FOCUS, self.OnInvalidPackagesSetFocus)
    self.InvalidPackagesCheckListBox.Bind(wx.EVT_KILL_FOCUS, self.OnInvalidPackagesKillFocus)
    self.InvalidPackagesCheckListBox.SetHelpText(PackagesHelpText)

    self.SelectAllInvalidPlatformsButton = wx.Button(panel, -1, 'Select All')
    self.ClearAllInvalidPlatformsButton  = wx.Button(panel, -1, 'Clear All')
    self.SelectAllInvalidPlatformsButton.Bind(wx.EVT_BUTTON, self.OnSelectAllInvalidPlatformsClick)
    self.ClearAllInvalidPlatformsButton.Bind (wx.EVT_BUTTON, self.OnClearAllInvalidPlatformsClick)

    self.InvalidPlatformsCheckListBox = wx.CheckListBox(panel, -1)
    self.InvalidPlatformsCheckListBox.Bind(wx.EVT_CHECKLISTBOX, self.OnInvalidPlatformsCheckListClick)
    self.InvalidPlatformsCheckListBox.Bind(wx.EVT_SET_FOCUS, self.OnInvalidPlatformsSetFocus)
    self.InvalidPlatformsCheckListBox.Bind(wx.EVT_KILL_FOCUS, self.OnInvalidPlatformsKillFocus)
    self.InvalidPlatformsCheckListBox.SetHelpText(PlatformsHelpText)

    #
    # Define layout using sizers
    #
    self.mainSizer = wx.BoxSizer(wx.VERTICAL)

    listSizer = wx.GridBagSizer(hgap=5, vgap=5)
    listSizer.Add(PackagesLabel,  pos=(0,0), span=(1,2), flag=wx.ALIGN_CENTER)
    listSizer.Add(PlatformsLabel, pos=(0,2), span=(1,2), flag=wx.ALIGN_CENTER)
    listSizer.Add(self.SelectAllPackagesButton, pos=(1,0), flag=wx.ALIGN_CENTER)
    listSizer.Add(self.ClearAllPackagesButton,  pos=(1,1), flag=wx.ALIGN_CENTER)
    listSizer.Add(self.SelectAllPlatformsButton, pos=(1,2), flag=wx.ALIGN_CENTER)
    listSizer.Add(self.ClearAllPlatformsButton,  pos=(1,3), flag=wx.ALIGN_CENTER)
    listSizer.Add(self.PackagesCheckListBox,  pos=(2,0), span=(1,2), flag=wx.ALL | wx.EXPAND)
    listSizer.Add(self.PlatformsCheckListBox, pos=(2,2), span=(1,2), flag=wx.ALL | wx.EXPAND)

    listSizer.Add(InvalidPackagesLabel,  pos=(3,0), span=(1,2), flag=wx.ALIGN_CENTER)
    listSizer.Add(InvalidPlatformsLabel, pos=(3,2), span=(1,2), flag=wx.ALIGN_CENTER)
    listSizer.Add(self.SelectAllInvalidPackagesButton, pos=(4,0), flag=wx.ALIGN_CENTER)
    listSizer.Add(self.ClearAllInvalidPackagesButton,  pos=(4,1), flag=wx.ALIGN_CENTER)
    listSizer.Add(self.SelectAllInvalidPlatformsButton, pos=(4,2), flag=wx.ALIGN_CENTER)
    listSizer.Add(self.ClearAllInvalidPlatformsButton,  pos=(4,3), flag=wx.ALIGN_CENTER)
    listSizer.Add(self.InvalidPackagesCheckListBox,  pos=(5,0), span=(1,2), flag=wx.ALL | wx.EXPAND)
    listSizer.Add(self.InvalidPlatformsCheckListBox, pos=(5,2), span=(1,2), flag=wx.ALL | wx.EXPAND)

    listSizer.AddGrowableRow(2)
    listSizer.AddGrowableRow(5)
    listSizer.AddGrowableCol(0)
    listSizer.AddGrowableCol(1)
    listSizer.AddGrowableCol(2)
    listSizer.AddGrowableCol(3)
    
    self.mainSizer.Add (listSizer, wx.EXPAND | wx.ALL, wx.EXPAND | wx.ALL, 10)    
    
    panel.SetSizer (self.mainSizer)

    self.OnViewRefreshClick(self)

  def CheckListFocus(self, CheckListBox, Set):
    Index = 0
    while Index < CheckListBox.GetCount():
      CheckListBox.SetSelection(Index, False)
      Index += 1
    if Set and CheckListBox.GetCount() > 0:
      CheckListBox.SetSelection(0, True)
    
  def CheckListClick(self, CheckListBox, Database):
    Index = 0
    Database['EnabledSettings'] = {}
    while Index < CheckListBox.GetCount():
      if CheckListBox.IsChecked(Index):
        for Item in Database['PossibleSettings']:
          if Database['PossibleSettings'][Item] == CheckListBox.GetString(Index):
            Database['EnabledSettings'][Item] = Database['PossibleSettings'][Item]
      Index += 1
     
  def OnPackagesCheckListClick(self, event):
    self.CheckListClick(self.PackagesCheckListBox, self.Model.Database['Package']['Valid'])

  def OnPackagesSetFocus(self, event):
    self.CheckListFocus(self.PackagesCheckListBox, True)

  def OnPackagesKillFocus(self, event):
    self.CheckListFocus(self.PackagesCheckListBox, False)
    
  def OnPlatformsCheckListClick(self, event):
    self.CheckListClick(self.PlatformsCheckListBox, self.Model.Database['Platform']['Valid'])

  def OnPlatformsSetFocus(self, event):
    self.CheckListFocus(self.PlatformsCheckListBox, True)

  def OnPlatformsKillFocus(self, event):
    self.CheckListFocus(self.PlatformsCheckListBox, False)

  def OnInvalidPackagesCheckListClick(self, event):
    self.CheckListClick(self.InvalidPackagesCheckListBox, self.Model.Database['Package']['Invalid'])

  def OnInvalidPackagesSetFocus(self, event):
    self.CheckListFocus(self.InvalidPackagesCheckListBox, True)

  def OnInvalidPackagesKillFocus(self, event):
    self.CheckListFocus(self.InvalidPackagesCheckListBox, False)
    
  def OnInvalidPlatformsCheckListClick(self, event):
    self.CheckListClick(self.InvalidPlatformsCheckListBox, self.Model.Database['Platform']['Invalid'])

  def OnInvalidPlatformsSetFocus(self, event):
    self.CheckListFocus(self.InvalidPlatformsCheckListBox, True)

  def OnInvalidPlatformsKillFocus(self, event):
    self.CheckListFocus(self.InvalidPlatformsCheckListBox, False)
    
  def OnRevertClick(self, event):
    self.Model.RevertModel()
    self.StatusBar.SetFocus()
    self.OnRefreshClick(self)

  def RefreshCheckListBox(self, CheckListBox, SelectAllButton, ClearAllButton, Database):
    NameList = []
    for Item in Database['PossibleSettings']:
      NameList.append(Database['PossibleSettings'][Item])
    NameList.sort()
    CheckListBox.Set(NameList)
    Index = 0
    MaximumString = '.'
    while Index < CheckListBox.GetCount():
      String = CheckListBox.GetString(Index)
      if len(String) > len(MaximumString):
        MaximumString = String
      Enabled = False
      for Item in Database['EnabledSettings']:
        if String == Database['EnabledSettings'][Item]:
          Enabled = True
      if Enabled:
        CheckListBox.Check(Index, True)
      else:
        CheckListBox.Check(Index, False)
      Index += 1
    Extents = CheckListBox.GetFullTextExtent (MaximumString)
    CheckListBox.SetMinSize((Extents[0] + 30,(CheckListBox.GetCount()+2) * (Extents[1]+Extents[2])))
    if NameList == []:
      CheckListBox.Disable()
      SelectAllButton.Disable()
      ClearAllButton.Disable()
    else:
      CheckListBox.Enable()
      SelectAllButton.Enable()
      ClearAllButton.Enable()
    
  def OnRefreshClick(self, event):
    self.Model.RefreshModel()
    self.RefreshCheckListBox (self.PackagesCheckListBox,  self.SelectAllPackagesButton, self.ClearAllPackagesButton, self.Model.Database['Package']['Valid'])
    self.RefreshCheckListBox (self.PlatformsCheckListBox, self.SelectAllPlatformsButton, self.ClearAllPlatformsButton, self.Model.Database['Platform']['Valid'])
    self.RefreshCheckListBox (self.InvalidPackagesCheckListBox,  self.SelectAllInvalidPackagesButton, self.ClearAllInvalidPackagesButton, self.Model.Database['Package']['Invalid'])
    self.RefreshCheckListBox (self.InvalidPlatformsCheckListBox, self.SelectAllInvalidPlatformsButton, self.ClearAllInvalidPlatformsButton, self.Model.Database['Platform']['Invalid'])
    self.mainSizer.SetSizeHints(self)
    self.mainSizer.Fit(self)
    self.Update()

  def OnViewRefreshClick(self, event):
    self.Model.RescanModel()
    self.StatusBar.SetFocus()
    self.OnRefreshClick(self)
   
  def AddTool (self, Handler, ArtId, Label, HelpText):
    Tool = self.ToolBar.AddSimpleTool(
      -1, 
      wx.ArtProvider.GetBitmap(ArtId, wx.ART_TOOLBAR, self.ToolSize), 
      Label, 
      HelpText
      )
    self.Bind(wx.EVT_MENU, Handler, Tool)
    
  def OnShowToolBarClick(self, event):
    if self.ShowToolBar:
      self.ShowToolBar = False
      self.ToolBar.Destroy()
    else:
      self.ShowToolBar = True
      self.ToolBar = self.CreateToolBar()
      self.ToolSize = (24,24)
      self.ToolBar.SetToolBitmapSize(self.ToolSize)
      self.AddTool (self.OnNewClick,         wx.ART_NEW,          "New",            "New FrameworkDatabase.db")  
      self.AddTool (self.OnScanAndSyncClick, wx.ART_HARDDISK,     "Scan WORKSPACE and Sync", "Scan WORKSPACE for new Packages and Platforms and sync FrameworkDatabase.db")  
      self.AddTool (self.OnSaveClick,        wx.ART_FILE_SAVE,    "Save",           "Save FrameworkDatabase.db")
      self.AddTool (self.OnSaveAsClick,      wx.ART_FILE_SAVE_AS, "Save As...",     "Save FrameworkDatabase.db as...")
      self.AddTool (self.OnRevertClick,      wx.ART_UNDO,         "Revert",         "Revert to original FrameworkDatabase.db")
      self.AddTool (self.OnHelpClick,        wx.ART_HELP,         "Help",           "Context Sensitive Help")
      self.AddTool (self.OnExitClick,        wx.ART_QUIT,         "Exit",           "Exit EDK II Build System Framework Database Utility")
      self.ToolBar.Realize()
  
  def OnNewClick(self, event):
    self.Model.NewModel()
    self.OnRefreshClick(self)

  def ScanDirectory(self, Data, DirName, FilesInDir):
    WorkspaceDirName = self.Model.WorkspaceRelativePath(DirName)
    self.StatusBar.SetStatusText('Scanning: ' + WorkspaceDirName)
    RemoveList = []
    for File in FilesInDir:
      if File[0] == '.':
        RemoveList.insert(0, File)
    for File in RemoveList:
      FilesInDir.remove(File)
    for File in FilesInDir:
      if os.path.splitext(File)[1].lower() == '.spd':
        self.Model.AddFile (WorkspaceDirName, File, 'Package', False)
        self.OnRefreshClick(self)
      if os.path.splitext(File)[1].lower() == '.fpd':
        self.Model.AddFile (WorkspaceDirName, File, 'Platform', False)
        self.OnRefreshClick(self)
    
  def OnScanClick(self, event):
    os.path.walk(self.Model.WorkspaceFile(''), self.ScanDirectory, None)
    self.StatusBar.SetStatusText('Scanning: Complete')
    self.StatusBar.SetFocus()
    self.OnRefreshClick(self)

  def OnScanAndSyncClick(self, event):
    self.OnSelectAllPackagesClick(self)
    self.OnSelectAllPlatformsClick(self)
    self.OnClearAllInvalidPackagesClick(self)
    self.OnClearAllInvalidPlatformsClick(self)
    self.OnScanClick(self)
    self.OnSelectAllPackagesClick(self)
    self.OnSelectAllPlatformsClick(self)
    self.OnClearAllInvalidPackagesClick(self)
    self.OnClearAllInvalidPlatformsClick(self)
    
  def OnSelectAllPackagesClick(self, event):
    self.Model.Database['Package']['Valid']['EnabledSettings'] = self.Model.Database['Package']['Valid']['PossibleSettings']
    self.OnRefreshClick(self)

  def OnClearAllPackagesClick(self, event):
    self.Model.Database['Package']['Valid']['EnabledSettings'] = {}
    self.OnRefreshClick(self)

  def OnSelectAllPlatformsClick(self, event):
    self.Model.Database['Platform']['Valid']['EnabledSettings'] = self.Model.Database['Platform']['Valid']['PossibleSettings']
    self.OnRefreshClick(self)

  def OnClearAllPlatformsClick(self, event):
    self.Model.Database['Platform']['Valid']['EnabledSettings'] = {}
    self.OnRefreshClick(self)

  def OnSelectAllInvalidPackagesClick(self, event):
    self.Model.Database['Package']['Invalid']['EnabledSettings'] = self.Model.Database['Package']['Invalid']['PossibleSettings']
    self.OnRefreshClick(self)

  def OnClearAllInvalidPackagesClick(self, event):
    self.Model.Database['Package']['Invalid']['EnabledSettings'] = {}
    self.OnRefreshClick(self)

  def OnSelectAllInvalidPlatformsClick(self, event):
    self.Model.Database['Platform']['Invalid']['EnabledSettings'] = self.Model.Database['Platform']['Invalid']['PossibleSettings']
    self.OnRefreshClick(self)

  def OnClearAllInvalidPlatformsClick(self, event):
    self.Model.Database['Platform']['Invalid']['EnabledSettings'] = {}
    self.OnRefreshClick(self)
    
  def OnSaveClick(self, event):
    self.Model.SaveModel()

  def OnSaveAsClick(self, event):
    wildcard = "Text Documents (*.db)|*.db|" \
               "All files (*.*)|*.*"
    dialog = wx.FileDialog (None, 'Save As', self.Model.WorkspaceFile('Tools/Conf'), '', wildcard, wx.SAVE | wx.OVERWRITE_PROMPT)
    if dialog.ShowModal() == wx.ID_OK:
      FrameworkDatabaseDbFile = self.Model.WorkspaceRelativePath(dialog.GetPath())
      if FrameworkDatabaseDbFile != '':
        self.Model.SaveModel(FrameworkDatabaseDbFile)
    dialog.Destroy()
  
  def OnExitClick(self, event):
    if self.Model.ModelModified():
      dialog = wx.MessageDialog(None, 'The contents have changed.\nDo you want to save changes?', 'EDK II Build System Framework Databsase Utility', style = wx.YES_NO | wx.YES_DEFAULT | wx.CANCEL | wx.ICON_EXCLAMATION)
      Status = dialog.ShowModal()
      dialog.Destroy()
      if Status == wx.ID_YES:
        self.OnSaveClick (self)
      elif Status == wx.ID_CANCEL:
        return
    self.Model.CloseModel()
    self.Close()

  def OnHelpClick(self, event):
    wx.ContextHelp().BeginContextHelp()

  def OnAboutClick(self, event):
    AboutInfo = wx.AboutDialogInfo()
    AboutInfo.Name = 'EDK II Build System Framework Database Utility'
    AboutInfo.Version = '0.3'
    AboutInfo.Copyright = 'Copyright (c) 2006, Intel Corporation'
    AboutInfo.Description = """
      The EDK II Build System Framework Database Utility maintains FrameworkDatabase.db 
      settings in an EDK II Workspace."""
    AboutInfo.WebSite = ("http://tianocore.org", "Tiano Core home page")
    AboutInfo.License = """
      All rights reserved. This program and the accompanying materials are 
      licensed and made available under the terms and conditions of the BSD 
      License which accompanies this distribution.  The full text of the 
      license may be found at http://opensource.org/licenses/bsd-license.php
      
      THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" 
      BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, 
      EITHER EXPRESS OR IMPLIED."""
    if self.Model.Icon != None:
      AboutInfo.Icon = self.Model.Icon
    wx.AboutBox(AboutInfo)

if __name__ == '__main__':
  app = wx.PySimpleApp()
  frame = Frame()
  frame.Show()
  app.MainLoop()