AddRFFromHDBDialog Class Reference

#include <AddRFFromHDBDialog.hh>

Inheritance diagram for AddRFFromHDBDialog:

Collaboration diagram for AddRFFromHDBDialog:

Public Member Functions
	AddRFFromHDBDialog (wxWindow *parent, Model *model)
virtual	~AddRFFromHDBDialog ()

Private Types
enum	{ ID_LIST = 10000 , ID_ADD , ID_CLOSE , ID_LINE }

Private Member Functions
virtual bool	TransferDataToWindow ()
wxSizer *	createContents (wxWindow *parent, bool call_fit, bool set_sizer)
void	onListSelectionChange (wxListEvent &event)
void	onAdd (wxCommandEvent &event)
void	onClose (wxCommandEvent &event)
bool	loadHDB (const HDB::HDBManager &manager)
void	onColumnClick (wxListEvent &event)
void	setColumnImage (int col, int image)

Private Attributes
Model *	model_
	Model of the current adf file.
wxListCtrl *	list_
	Immediate slot list widget.
std::map< int, HDB::RFArchitecture * >	rfArchitectures_
	Map of rf architectures displayed in the dialog list.
int	sortColumn_
bool	sortASC_

Static Private Attributes
static const int	DEFAULT_SIZE = 1
	Default size for the rf, if the size is parameterized in the HDB.
static const int	DEFAULT_WIDTH = 32
	Default bit width for the rf, if the size is parameterized in the HDB.
static const wxString	HDB_FILE_FILTER = _T("*.hdb")
	File filter for the HDB files.

Detailed Description

Dialog for adding register file architectures directly from HDB to the current machine.

Definition at line 64 of file AddRFFromHDBDialog.hh.

Member Enumeration Documentation

anonymous enum

anonymous enum

private

Enumerator
ID_LIST
ID_ADD
ID_CLOSE
ID_LINE

Definition at line 89 of file AddRFFromHDBDialog.hh.

         {
        ID_LIST = 10000,
        ID_ADD,
        ID_CLOSE,
        ID_LINE
    };

Constructor & Destructor Documentation

AddRFFromHDBDialog()

AddRFFromHDBDialog::AddRFFromHDBDialog	(	wxWindow *	parent,
		Model *	model
	)

The Constructor.

Parameters

parent	Parent window of the dialog.
machine	Parent Machine of the immediate slots.

Definition at line 142 of file AddRFFromHDBDialog.cc.

                  :
    wxDialog(
        parent, -1, _T("HDB Register Files"), wxDefaultPosition, wxDefaultSize,
        wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER),
    model_(model), sortColumn_(0), sortASC_(true) {
 
    createContents(this, true, true);
    SetSize(400, 300);
 
    list_ = dynamic_cast<wxListCtrl*>(FindWindow(ID_LIST));
 
    list_->InsertColumn(0, _T("Width"), wxLIST_FORMAT_LEFT, wxLIST_AUTOSIZE);
    list_->InsertColumn(1, _T("Size"), wxLIST_FORMAT_LEFT, wxLIST_AUTOSIZE);
    list_->InsertColumn(2, _T("Read ports"), wxLIST_FORMAT_LEFT, 100);
    list_->InsertColumn(3, _T("Write ports"), wxLIST_FORMAT_LEFT, 100);
    list_->InsertColumn(4, _T("Bidir ports"), wxLIST_FORMAT_LEFT, 100);
    list_->InsertColumn(5, _T("Max Reads"), wxLIST_FORMAT_LEFT, 100);
    list_->InsertColumn(6, _T("Max RW"), wxLIST_FORMAT_LEFT, 100);
    list_->InsertColumn(7, _T("ID"), wxLIST_FORMAT_LEFT, wxLIST_AUTOSIZE);
    list_->InsertColumn(8, _T("HDB"), wxLIST_FORMAT_LEFT, wxLIST_AUTOSIZE);
 
    string iconPath =
        Environment::iconDirPath() + FileSystem::DIRECTORY_SEPARATOR;
 
    wxImageList* imageList = new wxImageList(13, 17);
    imageList->Add(wxIcon(
        WxConversion::toWxString(iconPath + ProDeConstants::ICON_SORT_DESC)));
    imageList->Add(wxIcon(
        WxConversion::toWxString(iconPath + ProDeConstants::ICON_SORT_ASC)));
    list_->SetImageList(imageList, wxIMAGE_LIST_SMALL);
 
    // Disable conditional buttons.
    FindWindow(ID_ADD)->Disable();
}

References createContents(), FileSystem::DIRECTORY_SEPARATOR, ProDeConstants::ICON_SORT_ASC, ProDeConstants::ICON_SORT_DESC, Environment::iconDirPath(), ID_ADD, ID_LIST, list_, and WxConversion::toWxString().

Here is the call graph for this function:

~AddRFFromHDBDialog()

AddRFFromHDBDialog::~AddRFFromHDBDialog ( )

virtual

The Destructor.

Definition at line 183 of file AddRFFromHDBDialog.cc.

                                        {
}

Member Function Documentation

createContents()

wxSizer * AddRFFromHDBDialog::createContents ( wxWindow *  parent, bool  call_fit, bool  set_sizer  )

private

Creates the dialog contents.

Parameters

parent	Parent dialog of the contents.
call_fit	If true, fits the contents inside the dialog.
set_sizer	If true, sets the main sizer as dialog contents.

Returns

Top level sizer of the dialog contents.

Definition at line 387 of file AddRFFromHDBDialog.cc.

                                                     {
 
    wxFlexGridSizer *item0 = new wxFlexGridSizer( 1, 0, 0 );
    item0->AddGrowableCol( 0 );
    item0->AddGrowableRow( 0 );
 
    wxListCtrl *item1 = new wxListCtrl( parent, ID_LIST, wxDefaultPosition, wxSize(160,120), wxLC_REPORT|wxSUNKEN_BORDER );
    item0->Add( item1, 0, wxGROW|wxALL, 5 );
 
    wxButton *item2 = new wxButton( parent, ID_ADD, wxT("&Add"), wxDefaultPosition, wxDefaultSize, 0 );
    item0->Add( item2, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxALL, 5 );
 
    wxStaticLine *item3 = new wxStaticLine( parent, ID_LINE, wxDefaultPosition, wxSize(20,-1), wxLI_HORIZONTAL );
    item0->Add( item3, 0, wxGROW|wxALL, 5 );
 
    wxButton *item4 = new wxButton( parent, ID_CLOSE, wxT("&Close"), wxDefaultPosition, wxDefaultSize, 0 );
    item0->Add( item4, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxALL, 5 );
 
    if (set_sizer) {
        parent->SetSizer( item0 );
        if (call_fit) {
            item0->SetSizeHints( parent );
        }
    }
    
    return item0;
}

References ID_ADD, ID_CLOSE, ID_LINE, and ID_LIST.

Referenced by AddRFFromHDBDialog().

loadHDB()

bool AddRFFromHDBDialog::loadHDB ( const HDB::HDBManager &  manager )

private

Loads register files from a HDB to the dialog list.

Parameters

manager

HDBManager managing the HDB to load.

Returns

True, if the HDB was succesfully loaded.

Definition at line 231 of file AddRFFromHDBDialog.cc.

                                                        {
 
    std::string path = manager.fileName();
 
    const std::set<RowID> rfArchIDs = manager.rfArchitectureIDs();
    std::set<RowID>::iterator iter = rfArchIDs.begin();
 
    // Read properties of all register files in the HDB and append
    // data to the register file list widget.
    for (; iter != rfArchIDs.end(); iter++) {
 
        RFArchitecture* arch = manager.rfArchitectureByID(*iter);
 
        if (arch->latency() != 1) {
            continue;
        }
 
        rfArchitectures_.insert(
            std::pair<int, RFArchitecture*>(list_->GetItemCount(), arch));
 
        ListItemData* lid = new ListItemData;
 
        if (arch->hasParameterizedWidth()) {
            list_->InsertItem(0, _T("param"));
            lid->width = 0;
        } else {
            list_->InsertItem(0, WxConversion::toWxString(arch->width()));
            lid->width = arch->width();
        }
        if (arch->hasParameterizedSize()) {
            list_->SetItem(0, 1, _T("param"));
            lid->size = 0;
        } else {
            list_->SetItem(0, 1, WxConversion::toWxString(arch->size()));
            lid->size = arch->size();
        }
        list_->SetItem(0, 2, WxConversion::toWxString(arch->readPortCount()));
        lid->readPorts = arch->readPortCount();
        list_->SetItem(
            0, 3, WxConversion::toWxString(arch->writePortCount()));
        lid->writePorts = arch->writePortCount();
        list_->SetItem(0, 4, WxConversion::toWxString(arch->bidirPortCount()));
        lid->bidirPorts = arch->bidirPortCount();
        list_->SetItem(0, 5, WxConversion::toWxString(arch->maxReads()));
        lid->maxReads = arch->maxReads();
        list_->SetItem(0, 6, WxConversion::toWxString(arch->maxWrites()));
        lid->maxWrites = arch->maxWrites();
        list_->SetItem(0, 7, WxConversion::toWxString(*iter));
        lid->hdbId = *iter;
        list_->SetItem(0, 8, WxConversion::toWxString(path));
        lid->path = WxConversion::toWxString(path);
        lid->id = list_->GetItemCount() - 1;
        list_->SetItemData(0, (long)lid);
    }
    // default sorting column is "Width"
    list_->SortItems(RFListCompareASC, 0);
    setColumnImage(0, sortASC_);
 
    return true;
}

References HDB::RFArchitecture::bidirPortCount(), ListItemData::bidirPorts, HDB::HDBManager::fileName(), HDB::RFArchitecture::hasParameterizedSize(), HDB::RFArchitecture::hasParameterizedWidth(), ListItemData::hdbId, ListItemData::id, HDB::RFArchitecture::latency(), list_, HDB::RFArchitecture::maxReads(), ListItemData::maxReads, HDB::RFArchitecture::maxWrites(), ListItemData::maxWrites, ListItemData::path, HDB::RFArchitecture::readPortCount(), ListItemData::readPorts, HDB::HDBManager::rfArchitectureByID(), HDB::HDBManager::rfArchitectureIDs(), rfArchitectures_, RFListCompareASC(), setColumnImage(), HDB::RFArchitecture::size(), ListItemData::size, sortASC_, WxConversion::toWxString(), HDB::RFArchitecture::width(), ListItemData::width, HDB::RFArchitecture::writePortCount(), and ListItemData::writePorts.

Referenced by TransferDataToWindow().

Here is the call graph for this function:

onAdd()

void AddRFFromHDBDialog::onAdd ( wxCommandEvent &  event )

private

Adds a new register file to the machine when "Add" button is pressed.

Definition at line 309 of file AddRFFromHDBDialog.cc.

                                         {
 
    long item = -1;
    item = list_->GetNextItem(item, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
    if ( item == -1 ) return;
    
    ListItemData* lid = (ListItemData*)list_->GetItemData(item);
    int id = lid->id;
    const RFArchitecture* arch =
        MapTools::valueForKey<RFArchitecture*>(rfArchitectures_, id);
 
    Machine* machine = model_->getMachine();
 
    int size = DEFAULT_SIZE;
    int width = DEFAULT_WIDTH;
 
    if (!arch->hasParameterizedWidth()) {
        size = arch->width();
    }
 
    if (!arch->hasParameterizedSize()) {
        size = arch->size();
    }
 
    // Generate name for the new register file.
    string name =
        "RF_" + Conversion::toString(size) + "x" + Conversion::toString(width);
 
    string rfName = name;
    int idx = 1;
    while (machine->registerFileNavigator().hasItem(rfName)) {
        rfName = name + "_" + Conversion::toString(idx);
        idx++;
    }
 
    RegisterFile* rf = new RegisterFile(
        rfName, size, width, arch->maxReads(), arch->maxWrites(), 
        arch->guardLatency(), RegisterFile::NORMAL, arch->zeroRegister());
 
    for (int i = 0; i < arch->readPortCount(); i++) {
        string name = "r" + Conversion::toString(i);
        new RFPort(name, *rf);
    }
 
    for (int i = 0; i < arch->writePortCount(); i++) {
        string name = "w" + Conversion::toString(i);
        new RFPort(name, *rf);
    }
 
    for (int i = 0; i < arch->bidirPortCount(); i++) {
        string name = "rw" + Conversion::toString(i);
        new RFPort(name, *rf);
    }
 
    model_->pushToStack();
    machine->addRegisterFile(*rf);
    model_->notifyObservers();
    
}

References TTAMachine::Machine::addRegisterFile(), HDB::RFArchitecture::bidirPortCount(), DEFAULT_SIZE, DEFAULT_WIDTH, Model::getMachine(), HDB::RFArchitecture::guardLatency(), TTAMachine::Machine::Navigator< ComponentType >::hasItem(), HDB::RFArchitecture::hasParameterizedSize(), HDB::RFArchitecture::hasParameterizedWidth(), ListItemData::id, MapTools::keyForValue(), list_, machine, HDB::RFArchitecture::maxReads(), HDB::RFArchitecture::maxWrites(), model_, TTAMachine::RegisterFile::NORMAL, Model::notifyObservers(), Model::pushToStack(), HDB::RFArchitecture::readPortCount(), TTAMachine::Machine::registerFileNavigator(), rfArchitectures_, HDB::RFArchitecture::size(), Conversion::toString(), HDB::RFArchitecture::width(), HDB::RFArchitecture::writePortCount(), and HDB::RFArchitecture::zeroRegister().

Here is the call graph for this function:

onClose()

void AddRFFromHDBDialog::onClose ( wxCommandEvent &  event )

private

Closes the dialog when the close button is pressed.

Definition at line 373 of file AddRFFromHDBDialog.cc.

                                           {
    Close();
}

onColumnClick()

void AddRFFromHDBDialog::onColumnClick ( wxListEvent &  event )

private

Sorts HDB RF list according to clicked column.

Definition at line 421 of file AddRFFromHDBDialog.cc.

                                                    {
 
    int clickedColumn = event.GetColumn();
 
    if (clickedColumn == sortColumn_) {
        sortASC_ = !sortASC_;
    } else {
        sortASC_ = true;
        setColumnImage(sortColumn_, -1);    // removes arrow from old column
        sortColumn_ = clickedColumn;
    }
 
    setColumnImage(clickedColumn, sortASC_);
 
    if (sortASC_) {
        list_->SortItems(RFListCompareASC, clickedColumn);
    } else {
        list_->SortItems(RFListCompareDESC, clickedColumn);
    }
}

References list_, RFListCompareASC(), RFListCompareDESC(), setColumnImage(), sortASC_, and sortColumn_.

Here is the call graph for this function:

onListSelectionChange()

void AddRFFromHDBDialog::onListSelectionChange ( wxListEvent &  event )

private

Enables and disables the delete button according to slot list selection.

Definition at line 296 of file AddRFFromHDBDialog.cc.

                                                      {
    if (list_->GetSelectedItemCount() == 1) {
        FindWindow(ID_ADD)->Enable();
    } else {
        FindWindow(ID_ADD)->Disable();
    }
}

References ID_ADD, and list_.

setColumnImage()

void AddRFFromHDBDialog::setColumnImage ( int  col, int  image  )

private

Sets sorting arrow image on selected column

Parameters

col	Column index to set the image
image	Image index in wxImageList

Definition at line 450 of file AddRFFromHDBDialog.cc.

                                                     {
    wxListItem item;
    item.SetMask(wxLIST_MASK_IMAGE);
    item.SetImage(image);
    list_->SetColumn(col, item);
}

References list_.

Referenced by loadHDB(), and onColumnClick().

TransferDataToWindow()

bool AddRFFromHDBDialog::TransferDataToWindow ( )

privatevirtual

Transfers data from the HDBs to the dialog list.

Returns

True, if the data transfer was ssuccesful.

Definition at line 193 of file AddRFFromHDBDialog.cc.

                                         {
 
    MapTools::deleteAllValues(rfArchitectures_);
    list_->DeleteAllItems();
 
    HDBRegistry& registry = HDBRegistry::instance();
    registry.loadFromSearchPaths();
 
    for (int i = 0; i < registry.hdbCount(); i++) {
        loadHDB(registry.hdb(i));
    }
 
    wxString errorMessage;
    for (int i = 0; i < registry.hdbErrorCount(); i++) {
        errorMessage.Append(
            WxConversion::toWxString(registry.hdbErrorMessage(i)));
        errorMessage.Append(_T("\n"));
        WarningDialog dialog(this, errorMessage);
        dialog.ShowModal();
    }
 
    if (registry.hdbCount() < 1) {
        wxString message = _T("No HDBs found in HDB search paths.");
        WarningDialog dialog(this, message);
        dialog.ShowModal();
    }
 
    list_->SetColumnWidth(8, wxLIST_AUTOSIZE);
    return wxDialog::TransferDataToWindow();
}

References MapTools::deleteAllValues(), HDB::HDBRegistry::hdb(), HDB::HDBRegistry::hdbCount(), HDB::HDBRegistry::hdbErrorCount(), HDB::HDBRegistry::hdbErrorMessage(), HDB::HDBRegistry::instance(), list_, HDB::HDBRegistry::loadFromSearchPaths(), loadHDB(), rfArchitectures_, and WxConversion::toWxString().

Here is the call graph for this function:

Member Data Documentation

DEFAULT_SIZE

const int AddRFFromHDBDialog::DEFAULT_SIZE = 1

staticprivate

Default size for the rf, if the size is parameterized in the HDB.

Definition at line 97 of file AddRFFromHDBDialog.hh.

Referenced by onAdd().

DEFAULT_WIDTH

const int AddRFFromHDBDialog::DEFAULT_WIDTH = 32

staticprivate

Default bit width for the rf, if the size is parameterized in the HDB.

Definition at line 99 of file AddRFFromHDBDialog.hh.

Referenced by onAdd().

HDB_FILE_FILTER

const wxString AddRFFromHDBDialog::HDB_FILE_FILTER = _T("*.hdb")

staticprivate

File filter for the HDB files.

Definition at line 101 of file AddRFFromHDBDialog.hh.

list_

wxListCtrl* AddRFFromHDBDialog::list_

private

Immediate slot list widget.

Definition at line 82 of file AddRFFromHDBDialog.hh.

Referenced by AddRFFromHDBDialog(), loadHDB(), onAdd(), onColumnClick(), onListSelectionChange(), setColumnImage(), and TransferDataToWindow().

model_

Model* AddRFFromHDBDialog::model_

private

Model of the current adf file.

Definition at line 80 of file AddRFFromHDBDialog.hh.

Referenced by onAdd().

rfArchitectures_

std::map<int, HDB::RFArchitecture*> AddRFFromHDBDialog::rfArchitectures_

private

Map of rf architectures displayed in the dialog list.

Definition at line 84 of file AddRFFromHDBDialog.hh.

Referenced by loadHDB(), onAdd(), and TransferDataToWindow().

sortASC_

bool AddRFFromHDBDialog::sortASC_

private

Definition at line 87 of file AddRFFromHDBDialog.hh.

Referenced by loadHDB(), and onColumnClick().

sortColumn_

int AddRFFromHDBDialog::sortColumn_

private

Definition at line 86 of file AddRFFromHDBDialog.hh.

Referenced by onColumnClick().

---

The documentation for this class was generated from the following files:

• AddRFFromHDBDialog.hh
• AddRFFromHDBDialog.cc