InputOperandDialog Class Reference

#include <InputOperandDialog.hh>

Inheritance diagram for InputOperandDialog:

Collaboration diagram for InputOperandDialog:

Public Member Functions
	InputOperandDialog (wxWindow *parent, Operand *operand, int numberOfOperands, int operandIndex)
virtual	~InputOperandDialog ()

Private Types
enum	{   ID_MEM_ADDRESS = 1000 , ID_MEM_DATA , ID_SWAP_LIST , ID_OPERAND_CHOICE ,   ID_OPERATION_INPUT_TYPES , ID_ADD_BUTTON , ID_DELETE_BUTTON , ID_ELEMENT_WIDTH ,   ID_ELEMENT_COUNT , ID_TEXT_WIDTH , ID_TEXT_COUNT }

Private Member Functions
	InputOperandDialog (const InputOperandDialog &)
	Copying not allowed.
InputOperandDialog &	operator= (const InputOperandDialog &)
	Assignment not allowed.
wxSizer *	createContents (wxWindow *parent, bool call_fit, bool set_sizer)
virtual bool	TransferDataToWindow ()
void	updateList ()
void	onAddSwap (wxCommandEvent &event)
void	onDeleteSwap (wxCommandEvent &event)
void	onSelection (wxListEvent &event)
void	onOk (wxCommandEvent &event)
void	updateOperand ()
void	onType (wxCommandEvent &event)
void	onElementWidth (wxSpinEvent &event)
void	onElementCount (wxCommandEvent &event)
void	updateTypes ()
void	updateElementWidths ()
void	updateElementCounts ()
void	setTexts ()

Private Attributes
wxListCtrl *	swapList_
	List of can swap operands.
wxChoice *	swapChoice_
	Choice list for can swap operands.
wxStaticBoxSizer *	swapSizer_
	Pointer to can swap sizer.
Operand *	operand_
	Operand to be created or modified.
bool	memAddress_
	Flag indicating if operand is memory address.
bool	memData_
	Flag indicating if operand is memory data.
wxChoice *	inputTypesComboBox_
	Choice box for operation input types.
wxSpinCtrl *	elementWidthSpinCtrl_
	Spin ctrl for operand element width.
wxChoice *	elementCountChoice_
	Choice box for operand element count.
std::set< int >	canSwap_
	Operands that can be swapped with this operand.
int	numberOfOperands_
	Numberof input operands.
int	index_
	Index of the input operand currently modified.
int	type_
	Current operand type in choice box.
int	elemWidth_
	Current element width in choice box.
int	elemCount_
	Current element count in choice box.
std::vector< std::string >	inputTypes_
	Input types.
Operand::OperandType	operandTypes_ [9]

Detailed Description

Dialog for adding or modifying input operands.

Definition at line 47 of file InputOperandDialog.hh.

Member Enumeration Documentation

anonymous enum

anonymous enum

private

Component ids.

Enumerator
ID_MEM_ADDRESS
ID_MEM_DATA
ID_SWAP_LIST
ID_OPERAND_CHOICE
ID_OPERATION_INPUT_TYPES
ID_ADD_BUTTON
ID_DELETE_BUTTON
ID_ELEMENT_WIDTH
ID_ELEMENT_COUNT
ID_TEXT_WIDTH
ID_TEXT_COUNT

Definition at line 83 of file InputOperandDialog.hh.

         {
        ID_MEM_ADDRESS = 1000,
        ID_MEM_DATA,
        ID_SWAP_LIST,
        ID_OPERAND_CHOICE,
        ID_OPERATION_INPUT_TYPES, // Input Type ComboBox
        ID_ADD_BUTTON,
        ID_DELETE_BUTTON,
        ID_ELEMENT_WIDTH,
        ID_ELEMENT_COUNT,
        ID_TEXT_WIDTH,
        ID_TEXT_COUNT
    };

Constructor & Destructor Documentation

InputOperandDialog() [1/2]

InputOperandDialog::InputOperandDialog	(	wxWindow *	parent,
		Operand *	operand,
		int	numberOfOperands,
		int	operandIndex
	)

Constructor.

Parameters

parent	The parent window.
operand	Operand to be added or modified.
numberOfOperands	The number of input operands.

Definition at line 76 of file InputOperandDialog.cc.

                      :
    wxDialog(parent, -1, _T(""), 
             DialogPosition::getPosition(DialogPosition::DIALOG_INPUT_OPERAND)),
    operand_(operand), numberOfOperands_(numberOfOperands), 
    index_(operandIndex) {
 
    memAddress_ = operand_->isAddress();
    memData_ = operand_->isMemoryData();
    createContents(this, true, true);
 
    swapList_ = dynamic_cast<wxListCtrl*>(FindWindow(ID_SWAP_LIST));
    swapChoice_ = dynamic_cast<wxChoice*>(FindWindow(ID_OPERAND_CHOICE));
 
    inputTypesComboBox_ =
        dynamic_cast<wxChoice*>(FindWindow(ID_OPERATION_INPUT_TYPES));
 
    elementWidthSpinCtrl_ =
        dynamic_cast<wxSpinCtrl*>(FindWindow(ID_ELEMENT_WIDTH));
 
    elementCountChoice_ =
        dynamic_cast<wxChoice*>(FindWindow(ID_ELEMENT_COUNT));
    
    FindWindow(ID_MEM_ADDRESS)->SetValidator(wxGenericValidator(&memAddress_));
    FindWindow(ID_MEM_DATA)->SetValidator(wxGenericValidator(&memData_));
 
    FindWindow(wxID_OK)->SetFocus();
 
    canSwap_ = operand_->swap();
 
    inputTypes_.push_back(Operand::SINT_WORD_STRING);
    inputTypes_.push_back(Operand::UINT_WORD_STRING);
    inputTypes_.push_back(Operand::FLOAT_WORD_STRING);
    inputTypes_.push_back(Operand::DOUBLE_WORD_STRING);
    inputTypes_.push_back(Operand::HALF_FLOAT_WORD_STRING);
    inputTypes_.push_back(Operand::BOOL_STRING);
    inputTypes_.push_back(Operand::RAW_DATA_STRING);
    inputTypes_.push_back(Operand::SLONG_WORD_STRING);
    inputTypes_.push_back(Operand::ULONG_WORD_STRING);
 
    operandTypes_[0] = Operand::SINT_WORD;
    operandTypes_[1] = Operand::UINT_WORD;
    operandTypes_[2] = Operand::FLOAT_WORD;
    operandTypes_[3] = Operand::DOUBLE_WORD;
    operandTypes_[4] = Operand::HALF_FLOAT_WORD;
    operandTypes_[5] = Operand::BOOL;
    operandTypes_[6] = Operand::RAW_DATA;
    operandTypes_[7] = Operand::SLONG_WORD;
    operandTypes_[8] = Operand::ULONG_WORD;
 
    type_ = operand_->type();
    elemWidth_ = operand_->elementWidth();
    elemCount_ = operand_->elementCount();
    updateTypes();
    updateElementWidths();
    updateElementCounts();
    
    setTexts();
    }

References Operand::BOOL, Operand::BOOL_STRING, Operand::DOUBLE_WORD, Operand::DOUBLE_WORD_STRING, Operand::FLOAT_WORD, Operand::FLOAT_WORD_STRING, Operand::HALF_FLOAT_WORD, Operand::HALF_FLOAT_WORD_STRING, Operand::RAW_DATA, Operand::RAW_DATA_STRING, Operand::SINT_WORD, Operand::SINT_WORD_STRING, Operand::SLONG_WORD, Operand::SLONG_WORD_STRING, Operand::UINT_WORD, Operand::UINT_WORD_STRING, Operand::ULONG_WORD, and Operand::ULONG_WORD_STRING.

~InputOperandDialog()

InputOperandDialog::~InputOperandDialog ( )

virtual

Destructor.

Definition at line 142 of file InputOperandDialog.cc.

                                        {
    int x, y;
    GetPosition(&x, &y);
    wxPoint point(x, y);
    DialogPosition::setPosition(DialogPosition::DIALOG_INPUT_OPERAND, point);
}

References DialogPosition::DIALOG_INPUT_OPERAND, and DialogPosition::setPosition().

Here is the call graph for this function:

InputOperandDialog() [2/2]

InputOperandDialog::InputOperandDialog ( const InputOperandDialog &  )

private

Copying not allowed.

Member Function Documentation

createContents()

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

private

Creates the contents of dialog.

NOTE! This function is generated by wxDesigner, that is why it is ugly.

Parameters

parent	The parent window.
call_fir	If true, fits the contents of the dialog inside dialog.
set_sizer	If true, sets the main sizer as the contents of the dialog.

Returns

The created sizer.

Definition at line 513 of file InputOperandDialog.cc.

{
    wxBoxSizer *item0 = new wxBoxSizer(wxVERTICAL);
 
    wxBoxSizer *item1 = new wxBoxSizer(wxHORIZONTAL);
 
    wxString strs9[] = {
            wxT("id: 1")
    };
 
 
    // ComboBox for input operand types
    wxChoice *itemInputTypes = new wxChoice(parent, ID_OPERATION_INPUT_TYPES, wxDefaultPosition, wxSize(100,-1), 1, strs9);
    item1->Add(itemInputTypes, 0, wxALIGN_CENTER|wxALL, 5);
 
    wxStaticText *itemTextWidth = new wxStaticText(parent, ID_TEXT_WIDTH, wxT("Element width:"), wxDefaultPosition, wxDefaultSize, 0);
    item1->Add(itemTextWidth, 0, wxALIGN_CENTER|wxALL, 5);
    wxSpinCtrl *itemElemWidth = new wxSpinCtrl(parent, ID_ELEMENT_WIDTH, wxT(""), wxDefaultPosition, wxSize(-1,-1), 1);
    item1->Add(itemElemWidth, 0, wxALIGN_CENTER|wxALL, 5);
    wxStaticText *itemTextCount = new wxStaticText(parent, ID_TEXT_COUNT, wxT("Element count:"), wxDefaultPosition, wxDefaultSize, 0);
    item1->Add(itemTextCount, 0, wxALIGN_CENTER|wxALL, 5);
    wxChoice *itemElemCount = new wxChoice(parent, ID_ELEMENT_COUNT, wxDefaultPosition, wxSize(70,-1), 1, strs9);
    item1->Add(itemElemCount, 0, wxALIGN_CENTER|wxALL, 5);
 
    wxBoxSizer *item1b = new wxBoxSizer(wxHORIZONTAL);
 
    wxCheckBox *item2 = new wxCheckBox(parent, ID_MEM_ADDRESS, wxT("Memory address"), wxDefaultPosition, wxDefaultSize, 0);
    item1b->Add(item2, 0, wxALIGN_CENTER|wxALL, 5);
 
    wxCheckBox *item3 = new wxCheckBox(parent, ID_MEM_DATA, wxT("Memory data"), wxDefaultPosition, wxDefaultSize, 0);
    item1b->Add(item3, 0, wxALIGN_CENTER|wxALL, 5);
 
    item0->Add(item1, 0, wxALIGN_CENTER|wxALL, 5);
    item0->Add(item1b, 0, wxALIGN_CENTER|wxALL, 5);
 
    wxStaticBox *item5 = new wxStaticBox(parent, -1, wxT("Can swap"));
    wxStaticBoxSizer *item4 = new wxStaticBoxSizer(item5, wxVERTICAL);
    swapSizer_ = item4;
 
    wxListCtrl *item6 = new wxListCtrl(parent, ID_SWAP_LIST, wxDefaultPosition, wxSize(160,120), wxLC_REPORT|wxSUNKEN_BORDER);
    item4->Add(item6, 0, wxGROW|wxALL, 5);
 
    wxBoxSizer *item7 = new wxBoxSizer(wxHORIZONTAL);
    
    wxChoice *item8 = new wxChoice(parent, ID_OPERAND_CHOICE, wxDefaultPosition, wxSize(100,-1), 1, strs9, 0);
    item7->Add(item8, 0, wxALIGN_CENTER|wxALL, 5);
 
    wxButton *item9 = new wxButton(parent, ID_ADD_BUTTON, wxT("Add"), wxDefaultPosition, wxDefaultSize, 0);
    item7->Add(item9, 0, wxALIGN_CENTER|wxALL, 5);
 
    wxButton *item10 = new wxButton(parent, ID_DELETE_BUTTON, wxT("Delete"), wxDefaultPosition, wxDefaultSize, 0);
    item7->Add(item10, 0, wxALIGN_CENTER|wxALL, 5);
 
    item4->Add(item7, 0, wxALIGN_CENTER|wxALL, 5);
 
    item0->Add(item4, 0, wxALIGN_CENTER|wxALL, 5);
 
    wxGridSizer *item11 = new wxGridSizer(2, 0, 0);
 
    item11->Add(20, 20, 0, wxALIGN_CENTER|wxALL, 5);
 
    wxBoxSizer *item12 = new wxBoxSizer(wxHORIZONTAL);
 
    wxButton *item13 = new wxButton(parent, wxID_OK, wxT("&OK"), wxDefaultPosition, wxDefaultSize, 0);
    item12->Add(item13, 0, wxALIGN_CENTER|wxALL, 5);
 
    wxButton *item14 = new wxButton(parent, wxID_CANCEL, wxT("&Cancel"), wxDefaultPosition, wxDefaultSize, 0);
    item12->Add(item14, 0, wxALIGN_CENTER|wxALL, 5);
 
    item11->Add(item12, 0, wxGROW|wxALL, 5);
 
    item0->Add(item11, 0, wxALIGN_CENTER|wxALL, 5);
 
    if (set_sizer) {
        parent->SetSizer(item0);
        if (call_fit)
            item0->SetSizeHints(parent);
    }
    
    return item0;
}

References ID_ADD_BUTTON, ID_DELETE_BUTTON, ID_ELEMENT_COUNT, ID_ELEMENT_WIDTH, ID_MEM_ADDRESS, ID_MEM_DATA, ID_OPERAND_CHOICE, ID_OPERATION_INPUT_TYPES, ID_SWAP_LIST, ID_TEXT_COUNT, ID_TEXT_WIDTH, and swapSizer_.

onAddSwap()

void InputOperandDialog::onAddSwap ( wxCommandEvent &  event )

private

Handles the event when id is added to can swap list.

Definition at line 362 of file InputOperandDialog.cc.

                                             {
    wxString wxId = swapChoice_->GetStringSelection();
    string id = WxConversion::toString(wxId);
    canSwap_.insert(Conversion::toInt(id));
    updateList();
}

References canSwap_, swapChoice_, Conversion::toInt(), WxConversion::toString(), and updateList().

Here is the call graph for this function:

onDeleteSwap()

void InputOperandDialog::onDeleteSwap ( wxCommandEvent &  event )

private

Handles the event when id is deleted from can swap list.

It is also possible to delete multible ids from the list.

Definition at line 375 of file InputOperandDialog.cc.

                                                {
 
    vector<string> toBeDeleted;
    long item = -1;
    for (;;) {
        item = swapList_->GetNextItem(
            item, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
    
        if (item == -1) {
            break;
        }
        
        wxListItem info;
        info.SetId(item);
        info.SetColumn(0);
        swapList_->GetItem(info);
        toBeDeleted.push_back(WxConversion::toString(info.GetText()));
    }
 
    for (size_t i = 0; i < toBeDeleted.size(); i++) {
        int id = Conversion::toInt(toBeDeleted[i]);
        set<int>::iterator it = canSwap_.begin();
        while (it != canSwap_.end()) {
            if (*it == id) {
                canSwap_.erase(it);
                break;
            }
            it++;
        }
    }
 
    updateList();
}

References canSwap_, swapList_, Conversion::toInt(), WxConversion::toString(), and updateList().

Here is the call graph for this function:

onElementCount()

void InputOperandDialog::onElementCount ( wxCommandEvent &  event )

private

Event handler for element count choice box.

Definition at line 224 of file InputOperandDialog.cc.

                                                  {
    // get the current choice box value and convert it to integer
    int index = elementCountChoice_->GetSelection();
    wxString number = elementCountChoice_->GetString(index);
    long value;
    if(!number.ToLong(&value)) { 
        elemCount_ = 1;
        return;
    }
 
    // save current choice
    elemCount_ = static_cast<int>(value);
    // update spin ctrl range
    updateElementWidths();
}

References elemCount_, elementCountChoice_, and updateElementWidths().

Here is the call graph for this function:

onElementWidth()

void InputOperandDialog::onElementWidth ( wxSpinEvent &  event )

private

Event handler for element width spin ctrl.

Definition at line 214 of file InputOperandDialog.cc.

                                               {
    elemWidth_ = elementWidthSpinCtrl_->GetValue();
    // update choice box list cells
    updateElementCounts();
}

References elementWidthSpinCtrl_, elemWidth_, and updateElementCounts().

Here is the call graph for this function:

onOk()

void InputOperandDialog::onOk ( wxCommandEvent &  event )

private

Handles the event when OK button is pushed.

Definition at line 413 of file InputOperandDialog.cc.

                                        {
    TransferDataFromWindow();
    updateOperand();
    EndModal(wxID_OK);
}

References updateOperand().

Here is the call graph for this function:

onSelection()

void InputOperandDialog::onSelection ( wxListEvent &  event )

private

Definition at line 494 of file InputOperandDialog.cc.

                                            {
    if (swapList_->GetSelectedItemCount() == 0) {
        FindWindow(ID_DELETE_BUTTON)->Disable();
    } else {
        FindWindow(ID_DELETE_BUTTON)->Enable();
    }
}

References ID_DELETE_BUTTON, and swapList_.

Referenced by updateList().

onType()

void InputOperandDialog::onType ( wxCommandEvent &  event )

private

Event handler for operand type choice box.

Definition at line 199 of file InputOperandDialog.cc.

                                          {
 
    type_ = inputTypesComboBox_->GetSelection();
 
    Operand::OperandType operType = static_cast<Operand::OperandType>(type_);
    elemWidth_ = Operand::defaultElementWidth(operType);
    elemCount_ = 1;
    updateElementWidths();
    updateElementCounts();
}

References Operand::defaultElementWidth(), elemCount_, elemWidth_, inputTypesComboBox_, type_, updateElementCounts(), and updateElementWidths().

Here is the call graph for this function:

operator=()

InputOperandDialog & InputOperandDialog::operator= ( const InputOperandDialog &  )

private

Assignment not allowed.

setTexts()

void InputOperandDialog::setTexts ( )

private

Set texts to widgets.

Definition at line 153 of file InputOperandDialog.cc.

                             {
    
    GUITextGenerator& guiText = *GUITextGenerator::instance();
    OSEdTextGenerator& osedText = OSEdTextGenerator::instance();
    
    // title
    format fmt = 
        osedText.text(OSEdTextGenerator::TXT_INPUT_OPERAND_DIALOG_TITLE);
    fmt % index_;
    SetTitle(WxConversion::toWxString(fmt.str()));
 
    // buttons
    WidgetTools::setLabel(&guiText, FindWindow(wxID_OK),
                          GUITextGenerator::TXT_BUTTON_OK);
 
    WidgetTools::setLabel(&guiText, FindWindow(wxID_CANCEL),
                          GUITextGenerator::TXT_BUTTON_CANCEL);
 
    WidgetTools::setLabel(&guiText, FindWindow(ID_ADD_BUTTON),
                          GUITextGenerator::TXT_BUTTON_ADD);
 
    WidgetTools::setLabel(&guiText, FindWindow(ID_DELETE_BUTTON),
                          GUITextGenerator::TXT_BUTTON_DELETE);
 
    // column names
    fmt = osedText.text(OSEdTextGenerator::TXT_COLUMN_OPERAND);
    swapList_->InsertColumn(
        0, WxConversion::toWxString(fmt.str()), wxLIST_FORMAT_LEFT,
        OSEdConstants::DEFAULT_COLUMN_WIDTH);
 
    // check boxes
    WidgetTools::setLabel(&osedText, FindWindow(ID_MEM_DATA),
                          OSEdTextGenerator::TXT_CHECKBOX_MEM_DATA);
 
    WidgetTools::setLabel(&osedText, FindWindow(ID_MEM_ADDRESS),
                          OSEdTextGenerator::TXT_CHECKBOX_MEM_ADDRESS);
 
    // sizer
    fmt = osedText.text(OSEdTextGenerator::TXT_BOX_CAN_SWAP);
    WidgetTools::setWidgetLabel(swapSizer_, fmt.str());
}

References OSEdConstants::DEFAULT_COLUMN_WIDTH, ID_ADD_BUTTON, ID_DELETE_BUTTON, ID_MEM_ADDRESS, ID_MEM_DATA, index_, GUITextGenerator::instance(), OSEdTextGenerator::instance(), WidgetTools::setLabel(), WidgetTools::setWidgetLabel(), swapList_, swapSizer_, Texts::TextGenerator::text(), WxConversion::toWxString(), OSEdTextGenerator::TXT_BOX_CAN_SWAP, GUITextGenerator::TXT_BUTTON_ADD, GUITextGenerator::TXT_BUTTON_CANCEL, GUITextGenerator::TXT_BUTTON_DELETE, GUITextGenerator::TXT_BUTTON_OK, OSEdTextGenerator::TXT_CHECKBOX_MEM_ADDRESS, OSEdTextGenerator::TXT_CHECKBOX_MEM_DATA, OSEdTextGenerator::TXT_COLUMN_OPERAND, and OSEdTextGenerator::TXT_INPUT_OPERAND_DIALOG_TITLE.

Here is the call graph for this function:

TransferDataToWindow()

bool InputOperandDialog::TransferDataToWindow ( )

privatevirtual

Transfers data to window.

Returns

True if transfer is successful.

Definition at line 318 of file InputOperandDialog.cc.

                                         {
    updateList();
    return wxWindow::TransferDataToWindow();
}

References updateList().

Here is the call graph for this function:

updateElementCounts()

void InputOperandDialog::updateElementCounts ( )

private

Updates the element count choice box list.

Definition at line 294 of file InputOperandDialog.cc.

                                        {
 
    elementCountChoice_->Clear();
    
    // update the list so that only shorter or equal than SIMD_WORD_WIDTH 
    // width*count combinations are listed 
    int elemCount = 1;
    int elemCountIndex = 0;
    while (elemCount*elemWidth_ <= SIMD_WORD_WIDTH) {
        if (elemCount < elemCount_) {
            ++elemCountIndex;
        }
        elementCountChoice_->Append(WxConversion::toWxString(elemCount));
        elemCount *= 2;
    }
    elementCountChoice_->SetSelection(elemCountIndex);
}

References elemCount_, elementCountChoice_, elemWidth_, SIMD_WORD_WIDTH, and WxConversion::toWxString().

Referenced by onElementWidth(), and onType().

Here is the call graph for this function:

updateElementWidths()

void InputOperandDialog::updateElementWidths ( )

private

Updates the element width choice box list.

Definition at line 260 of file InputOperandDialog.cc.

                                        {
 
    Operand::OperandType operType = static_cast<Operand::OperandType>(type_);
 
    if (operType == Operand::RAW_DATA) {
        // element width for raw data can be arbitrary up to the max width
        int elemWidth = 1;
        int lastValidWidth = 1;
        while (elemCount_*elemWidth <= SIMD_WORD_WIDTH) {
            lastValidWidth = elemWidth;
            elemWidth *= 2;
        }
 
        // degrade current element width if it is too big
        if (elemWidth_ > lastValidWidth) {
            elemWidth_ = lastValidWidth;
        }
        elementWidthSpinCtrl_->SetRange(1, lastValidWidth);
        elementWidthSpinCtrl_->SetValue(elemWidth_);
    } else if (operType == Operand::SINT_WORD || operType == Operand::UINT_WORD) {
        // element width for integers is 8 to 32
        elementWidthSpinCtrl_->SetRange(8, 32);
        elementWidthSpinCtrl_->SetValue(elemWidth_);
    } else {
        // element width for other types is their default type width
        elementWidthSpinCtrl_->SetRange(elemWidth_, elemWidth_);
        elementWidthSpinCtrl_->SetValue(elemWidth_);
    }
}

References elemCount_, elementWidthSpinCtrl_, elemWidth_, Operand::RAW_DATA, SIMD_WORD_WIDTH, Operand::SINT_WORD, type_, and Operand::UINT_WORD.

Referenced by onElementCount(), and onType().

updateList()

void InputOperandDialog::updateList ( )

private

Updates the list of can swap operands.

Definition at line 327 of file InputOperandDialog.cc.

                               {
 
    swapList_->DeleteAllItems();
    swapChoice_->Clear();
 
    set<int>::iterator it = canSwap_.begin();
    int i = 0;
    while (it != canSwap_.end()) {
        wxString id = WxConversion::toWxString(*it);
        swapList_->InsertItem(i, id);
        i++;
        it++;
    }
    
    for (int i = 1; i <= numberOfOperands_; i++) {
        if (i != index_ && 
            swapList_->FindItem(-1, WxConversion::toWxString(i)) == -1) {
            
            swapChoice_->Append(WxConversion::toWxString(i));
        }
    }
    swapChoice_->SetSelection(0);
    if (swapChoice_->GetCount() == 0) {
        FindWindow(ID_ADD_BUTTON)->Disable();
    } else {
        FindWindow(ID_ADD_BUTTON)->Enable();
    }
    wxListEvent dummy;
    onSelection(dummy);
}

References canSwap_, dummy, ID_ADD_BUTTON, index_, numberOfOperands_, onSelection(), swapChoice_, swapList_, and WxConversion::toWxString().

Referenced by onAddSwap(), onDeleteSwap(), and TransferDataToWindow().

Here is the call graph for this function:

updateOperand()

void InputOperandDialog::updateOperand ( )

private

Loads the properties to the modified/created operand.

Definition at line 423 of file InputOperandDialog.cc.

                                  {
    ObjectState* root = new ObjectState("");
    root->setAttribute(Operand::OPRND_ID, numberOfOperands_ + 1);
    
    int selected = inputTypesComboBox_->GetSelection();
    Operand::OperandType type = operandTypes_[selected];
    
 
    switch(type) {
        case Operand::SINT_WORD:
            root->setAttribute(Operand::OPRND_TYPE, Operand::SINT_WORD_STRING);
            break;
        case Operand::UINT_WORD:
            root->setAttribute(Operand::OPRND_TYPE, Operand::UINT_WORD_STRING);
            break;
        case Operand::FLOAT_WORD:
            root->setAttribute(Operand::OPRND_TYPE, Operand::FLOAT_WORD_STRING);
            break;
        case Operand::DOUBLE_WORD:
            root->setAttribute(Operand::OPRND_TYPE, Operand::DOUBLE_WORD_STRING);
            break;
        case Operand::HALF_FLOAT_WORD:
            root->setAttribute(
                Operand::OPRND_TYPE, Operand::HALF_FLOAT_WORD_STRING);
            break;
        case Operand::BOOL:
            root->setAttribute(Operand::OPRND_TYPE, Operand::BOOL_STRING);
            break;
        case Operand::RAW_DATA:
            root->setAttribute(
                Operand::OPRND_TYPE, Operand::RAW_DATA_STRING);
            break;
        case Operand::SLONG_WORD:
            root->setAttribute(
                Operand::OPRND_TYPE, Operand::SLONG_WORD_STRING);
            break;
        case Operand::ULONG_WORD:
            root->setAttribute(
                Operand::OPRND_TYPE, Operand::ULONG_WORD_STRING);
            break;
        default:
            root->setAttribute(Operand::OPRND_TYPE, Operand::SINT_WORD_STRING);
            break;
    }
 
    root->setAttribute(Operand::OPRND_ELEM_WIDTH, elemWidth_);
    root->setAttribute(Operand::OPRND_ELEM_COUNT, elemCount_);
    
    root->setAttribute(Operand::OPRND_MEM_ADDRESS, memAddress_);
    root->setAttribute(Operand::OPRND_MEM_DATA, memData_);
    
    if (canSwap_.size() > 0) {
        ObjectState* swap = new ObjectState(Operand::OPRND_CAN_SWAP);
        set<int>::iterator it = canSwap_.begin();
        while (it != canSwap_.end()) {
            ObjectState* swapChild = new ObjectState(Operand::OPRND_IN);
            swapChild->setAttribute(Operand::OPRND_ID, *it);
            swap->addChild(swapChild);
            it++;
        }
        root->addChild(swap);
    }
    
    operand_->loadState(root);
    delete root;
}

References ObjectState::addChild(), Operand::BOOL, Operand::BOOL_STRING, canSwap_, Operand::DOUBLE_WORD, Operand::DOUBLE_WORD_STRING, elemCount_, elemWidth_, Operand::FLOAT_WORD, Operand::FLOAT_WORD_STRING, Operand::HALF_FLOAT_WORD, Operand::HALF_FLOAT_WORD_STRING, inputTypesComboBox_, Operand::loadState(), memAddress_, memData_, numberOfOperands_, operand_, operandTypes_, Operand::OPRND_CAN_SWAP, Operand::OPRND_ELEM_COUNT, Operand::OPRND_ELEM_WIDTH, Operand::OPRND_ID, Operand::OPRND_IN, Operand::OPRND_MEM_ADDRESS, Operand::OPRND_MEM_DATA, Operand::OPRND_TYPE, Operand::RAW_DATA, Operand::RAW_DATA_STRING, ObjectState::setAttribute(), Operand::SINT_WORD, Operand::SINT_WORD_STRING, Operand::SLONG_WORD, Operand::SLONG_WORD_STRING, Operand::UINT_WORD, Operand::UINT_WORD_STRING, Operand::ULONG_WORD, and Operand::ULONG_WORD_STRING.

Referenced by onOk().

Here is the call graph for this function:

updateTypes()

void InputOperandDialog::updateTypes ( )

private

Updates the type lists.

Definition at line 244 of file InputOperandDialog.cc.

                                {
 
    inputTypesComboBox_->Clear();
    
    for (unsigned int i = 0; i < inputTypes_.size(); i++) {
        wxString oper = WxConversion::toWxString(inputTypes_.at(i));
        inputTypesComboBox_->Append(oper);
    }
    
    inputTypesComboBox_->SetSelection(type_);
}

References inputTypes_, inputTypesComboBox_, WxConversion::toWxString(), and type_.

Here is the call graph for this function:

Member Data Documentation

canSwap_

std::set<int> InputOperandDialog::canSwap_

private

Operands that can be swapped with this operand.

Definition at line 116 of file InputOperandDialog.hh.

Referenced by onAddSwap(), onDeleteSwap(), updateList(), and updateOperand().

elemCount_

int InputOperandDialog::elemCount_

private

Current element count in choice box.

Definition at line 126 of file InputOperandDialog.hh.

Referenced by onElementCount(), onType(), updateElementCounts(), updateElementWidths(), and updateOperand().

elementCountChoice_

wxChoice* InputOperandDialog::elementCountChoice_

private

Choice box for operand element count.

Definition at line 114 of file InputOperandDialog.hh.

Referenced by onElementCount(), and updateElementCounts().

elementWidthSpinCtrl_

wxSpinCtrl* InputOperandDialog::elementWidthSpinCtrl_

private

Spin ctrl for operand element width.

Definition at line 112 of file InputOperandDialog.hh.

Referenced by onElementWidth(), and updateElementWidths().

elemWidth_

int InputOperandDialog::elemWidth_

private

Current element width in choice box.

Definition at line 124 of file InputOperandDialog.hh.

Referenced by onElementWidth(), onType(), updateElementCounts(), updateElementWidths(), and updateOperand().

index_

int InputOperandDialog::index_

private

Index of the input operand currently modified.

Definition at line 120 of file InputOperandDialog.hh.

Referenced by setTexts(), and updateList().

inputTypes_

std::vector<std::string> InputOperandDialog::inputTypes_

private

Input types.

Definition at line 129 of file InputOperandDialog.hh.

Referenced by updateTypes().

inputTypesComboBox_

wxChoice* InputOperandDialog::inputTypesComboBox_

private

Choice box for operation input types.

Definition at line 110 of file InputOperandDialog.hh.

Referenced by onType(), updateOperand(), and updateTypes().

memAddress_

bool InputOperandDialog::memAddress_

private

Flag indicating if operand is memory address.

Definition at line 106 of file InputOperandDialog.hh.

Referenced by updateOperand().

memData_

bool InputOperandDialog::memData_

private

Flag indicating if operand is memory data.

Definition at line 108 of file InputOperandDialog.hh.

Referenced by updateOperand().

numberOfOperands_

int InputOperandDialog::numberOfOperands_

private

Numberof input operands.

Definition at line 118 of file InputOperandDialog.hh.

Referenced by updateList(), and updateOperand().

operand_

Operand* InputOperandDialog::operand_

private

Operand to be created or modified.

Definition at line 104 of file InputOperandDialog.hh.

Referenced by updateOperand().

operandTypes_

Operand::OperandType InputOperandDialog::operandTypes_[9]

private

Definition at line 131 of file InputOperandDialog.hh.

Referenced by updateOperand().

swapChoice_

wxChoice* InputOperandDialog::swapChoice_

private

Choice list for can swap operands.

Definition at line 100 of file InputOperandDialog.hh.

Referenced by onAddSwap(), and updateList().

swapList_

wxListCtrl* InputOperandDialog::swapList_

private

List of can swap operands.

Definition at line 98 of file InputOperandDialog.hh.

Referenced by onDeleteSwap(), onSelection(), setTexts(), and updateList().

swapSizer_

wxStaticBoxSizer* InputOperandDialog::swapSizer_

private

Pointer to can swap sizer.

Definition at line 102 of file InputOperandDialog.hh.

Referenced by createContents(), and setTexts().

type_

int InputOperandDialog::type_

private

Current operand type in choice box.

Definition at line 122 of file InputOperandDialog.hh.

Referenced by onType(), updateElementWidths(), and updateTypes().

---

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

• InputOperandDialog.hh
• InputOperandDialog.cc