//*************************************************************************
// Method: SetGroupPosition
// Description: sets the position of a group relative to other groups
//
// Parameters:
// group - the name of the group to set the position for
// position - the position to set
//
// Return Value: None
//*************************************************************************
void DockablePaneManager::SetGroupPosition(String *group, DockablePanePosition position)
{
if (groupPositionsTable->ContainsKey(group))
groupPositionsTable->set_Item(group, __box(position));
else
groupPositionsTable->Add(group, __box(position));
}
//*************************************************************************
// Method: onControlPageEnter
// Description: Called when a page is being entered
//
// Parameters:
// wp - The wizard page being entered
// wc - The wizard control changing the pages
//
// Return Value: None
//*************************************************************************
void AddCustomInterceptWizard::onControlPageEnter(WizardPage *wp, WizardControl *wc)
{
String *dialogTitle = String::Concat(originalTitle, " - Page ", __box(wc->SelectedIndex + 1)->ToString());
dialogTitle = String::Concat(dialogTitle, " of ", __box(wc->WizardPages->Count)->ToString());
this->Text = dialogTitle;
}
//*************************************************************************
// Method: AddDataArray
// Description: Called when a new test application has been launched
//
// Parameters:
// data - the data array associated with the new application
//
// Return Value: None
//*************************************************************************
void ResourcePane::AddDataArray(ResourcePaneDataArray *data)
{
int index = dataArrayList->IndexOfKey(__box(data->ProcessID.GetHashCode()));
if (index >= 0)
dataArrayList->SetByIndex(index, data);
else
dataArrayList->Add(__box(data->ProcessID.GetHashCode()), data);
}
//*************************************************************************
// Method: onCreateFault
// Description: Called when a ui pane creates a fault
//
// Parameters:
// dataNode - the node to create
//
// Return Value: none
//*************************************************************************
void FaultPaneDataArray::onCreateFault(DisplayableDataNode *dataNode)
{
FaultPaneDataNode *faultNode = dynamic_cast <FaultPaneDataNode*> (dataNode);
if (!faultNode)
return;
//retain a copy in dataarray for use when project pane makes a datanode copy
faultNode->DataArray = faultNode;
if (!faultNode->CreatedDelegate)
return;
else if (faultNode->processID == processID)
{
FaultFunctionDB *faultDB = FaultFunctionDB::GetInstance();
IList *faults = faultDB->Faults;
for (int i=0; i<faults->Count; i++)
{
Fault *fault = dynamic_cast <Fault*> (faults->Item[i]);
if (FaultsMatch(faultNode, fault))
{
faultNode->FaultID = fault->FaultID;
faultNode->ID = String::Concat(faultNode->processID.ToString(), faultNode->threadID.ToString(), faultNode->FaultID.ToString());
break;
}
}
if (faultNode->FaultID == -1)
return;
//if we are switching to a new fault, then delete the old one.
if (FindFaultNode(faultNode->Type, faultNode->threadID))
{
internalDelete = true;
onDeleteFault(faultNode);
internalDelete = false;
}
if (!this->itemList->Contains(faultNode->ID))
{
ArrayList *list = new ArrayList();
list->Add(__box(faultNode->threadID));
Array *threadList = list->ToArray();
holoScriptApp->InjectFault(threadList, faultNode->FaultID);
CreateDataNode(faultNode);
Object *args[] = __gc new Object*[1];
args[0] = faultNode;
faultNode->CreatedDelegate->DynamicInvoke(args);
}
else
return;
}
}
int32_t __array<T>::System_Collections_IList_IndexOf(::CoreLib::System::Object* obj)
{
for (auto index = 0; index < _length; index++)
{
if (__box(this->_data[index])->Equals(obj))
{
return index;
}
}
return -1;
}
WrappedValidationMessageLevel ValidationMessageInfo::GetLevel(
System::UInt32 messageUID,
System::Uri __gc* pRulesUri)
{
enum RulesSet
{
RulesSetStandard,
RulesSetStrict
};
if (pRulesUri == NULL) throw new System::ArgumentNullException();
RulesSet rulesSet;
if (pRulesUri->Equals(ValidationMessageInfo::pRuleUriStandardRules))
{
rulesSet = RulesSetStandard;
}
else if (pRulesUri->Equals(ValidationMessageInfo::pRuleUriStrictRules))
{
rulesSet = RulesSetStrict;
}
else
{
throw new System::ArgumentException();
}
WrappedValidationMessageLevel level;
System::Object __gc* oMessageUID = __box(messageUID);
System::Object __gc* oLevel = NULL;
switch (rulesSet)
{
case RulesSetStandard:
oLevel = pLevelTable->get_Item(oMessageUID);
if (oLevel == NULL) oLevel = pLevelTableStandard->get_Item(oMessageUID);
break;
case RulesSetStrict:
oLevel = pLevelTable->get_Item(oMessageUID);
if (oLevel == NULL) oLevel = pLevelTableStrict->get_Item(oMessageUID);
break;
default:
System::Diagnostics::Trace::Assert(false);
break;
}
if (oLevel != NULL)
{
// unbox
level = *dynamic_cast<__box WrappedValidationMessageLevel*>(oLevel);
}
else
{
throw new System::NotImplementedException();
// level = WrappedValidationMessageLevel::None;
}
return level;
}
bool __array<T>::System_Collections_IList_Contains(::CoreLib::System::Object* obj)
{
for (auto index = 0; index < _length; index++)
{
if (__box(this->_data[index])->Equals(obj))
{
return true;
}
}
return false;
}
//*************************************************************************
// Method: ResourceTestResourceSelectionPage
// Description: Constructor for the ResourceTestResourceSelectionPage class
//
// Parameters:
// None
//
// Return Value: None
//*************************************************************************
ResourceTestResourceSelectionPage::ResourceTestResourceSelectionPage(SortedList *resourcePaths, bool inModifyMode) : WizardPage()
{
SortedList *registryPaths = dynamic_cast <SortedList*> (resourcePaths->Item[__box(UIData::RegistryEntry)]);
SortedList *filePaths = dynamic_cast <SortedList*> (resourcePaths->Item[__box(UIData::File)]);
SortedList *processPaths = dynamic_cast <SortedList*> (resourcePaths->Item[__box(UIData::Process)]);
SortedList *comPaths = dynamic_cast <SortedList*> (resourcePaths->Item[__box(UIData::ComObject)]);
this->Dock = DockStyle::Fill;
this->SubTitle = "Select a Resource to create the test for the entire process";
Label *resourceLabel = new Label();
resourceLabel->Text = "Full resource path:";
resourceLabel->Location = System::Drawing::Point(8, 12);
resourceLabel->Size = System::Drawing::Size(176, 16);
resourceValue = new Label();
resourceValue->Text = "";
resourceValue->Location = System::Drawing::Point(8, 28);
resourceValue->Size = System::Drawing::Size(378, 16);
resourceTreeView = new ResourceTreeView(!inModifyMode, true);
if (processPaths)
resourceTreeView->AddResourceTree(UIData::Process, processPaths);
if (filePaths)
resourceTreeView->AddResourceTree(UIData::File, filePaths);
if (registryPaths)
resourceTreeView->AddResourceTree(UIData::RegistryEntry, registryPaths);
if (comPaths)
resourceTreeView->AddResourceTree(UIData::ComObject, comPaths);
resourceTreeView->Location = System::Drawing::Point(8, 56);
resourceTreeView->Size = System::Drawing::Size(350, 180);
resourceTreeView->OnResourceClicked += new ResourceClickedDelegate(this, onResourceClicked);
this->Controls->Add(resourceLabel);
this->Controls->Add(resourceValue);
this->Controls->Add(resourceTreeView);
}
//*************************************************************************
// Method: onFocusChanged
// Description: Called when ui focus changes
//
// Parameters:
// dataNode - node associated with the focus change
//
// Return Value: None
//*************************************************************************
void ResourcePane::onFocusChanged(DisplayableDataNode *dataNode)
{
if (ignoreFocusChange)
return;
if (!dataNode)
{
resourceTreeView->Clear();
return;
}
unsigned int processID = 0, localThreadID = 0;
if ( dataNode && (dataNode->processID != 0) )
{
processID = dataNode->processID;
localThreadID = dataNode->threadID;
}
else
return;
if ( (!dataArray) || (this->ProcessID != processID) || (localThreadID != this->threadID) )
{
this->threadID = localThreadID;
if (dataArray)
{
dataArray->onItemAdded -= itemAddedHandler;
dataArray->onItemModified -= itemModifiedHandler;
}
resourceTreeView->Clear();
int index = dataArrayList->IndexOfKey(__box(processID.GetHashCode()));
if (index >= 0)
{
dataArray = dynamic_cast <ResourcePaneDataArray*> (dataArrayList->GetByIndex(index));
itemAddedHandler = new ItemAddedDelegate(this, onItemAdded);
dataArray->onItemAdded += itemAddedHandler;
itemModifiedHandler = new ItemModifiedDelegate(this, onItemModified);
dataArray->onItemModified += itemModifiedHandler;
dataArray->Refresh();
}
else
dataArray = NULL;
}
}
//*************************************************************************
// Method: onDeleteFault
// Description: Called when a ui pane deletes a fault
//
// Parameters:
// dataNode - the node to delete
//
// Return Value: none
//*************************************************************************
void FaultPaneDataArray::onDeleteFault(DisplayableDataNode *dataNode)
{
FaultPaneDataNode *faultNode = dynamic_cast <FaultPaneDataNode*> (dataNode);
if (!faultNode)
{
faultNode = dynamic_cast <FaultPaneDataNode*> (dataNode->DataArray);
if (!faultNode)
return;
}
if (!faultNode->DeletedDelegate)
return;
else if (faultNode->processID == processID)
{
switch (faultNode->Type)
{
case UIData::DiskFault:
case UIData::MemoryFault:
case UIData::NetworkFault:
case UIData::RegistryFault:
case UIData::ProcessFault:
case UIData::CustomFault:
faultNode = FindFaultNode(faultNode->Type, faultNode->threadID);
if (!faultNode)
return;
break;
}
ArrayList *list = new ArrayList();
list->Add(__box(faultNode->threadID));
Array *threadList = list->ToArray();
holoScriptApp->RemoveFault(threadList, faultNode->FaultID);
if (internalDelete)
this->itemList->Remove(faultNode->ID);
else
DeleteDataNode(faultNode);
Object *args[] = __gc new Object*[1];
args[0] = faultNode;
faultNode->DeletedDelegate->DynamicInvoke(args);
}
}
//*************************************************************************
// Method: onProcessRemoved
// Description: Refreshes the UI after a process is removed from the project
//
// Parameters:
// processID - the pid of the process which was removed
//
// Return Value: None
//*************************************************************************
void ResourcePane::onProcessRemoved(unsigned int processID)
{
//clear the pane ui
resourceTreeView->Clear();
//clear the data array out of the data array list
int index = dataArrayList->IndexOfKey(__box(processID.GetHashCode()));
if (index >= 0)
{
//if the removed process was the current, set current to NULL
if (dataArray && (dataArray == dynamic_cast <ResourcePaneDataArray*> (dataArrayList->GetByIndex(index))))
{
dataArray->onItemAdded -= itemAddedHandler;
dataArray->onItemModified -= itemModifiedHandler;
dataArray = NULL;
}
dataArrayList->RemoveAt(index);
}
//refresh the pane ui
this->Refresh();
}
//*************************************************************************
// Method: AddCustomInterceptWizard
// Description: Constructor for the AddCustomInterceptWizard class
//
// Parameters:
// None
//
// Return Value: None
//*************************************************************************
AddCustomInterceptWizard::AddCustomInterceptWizard() : Form()
{
wizardControl = new AddCustomInterceptWizardControl();
originalTitle = "Add Holodeck Intercepts Wizard";
this->Text = String::Concat(originalTitle, " Page 1 of ", __box(wizardControl->WizardPages->Count)->ToString());
wizardControl->WizardPageEnter += new Crownwood::Magic::Controls::WizardControl::WizardPageHandler(this, onControlPageEnter);
wizardControl->WizardPageLeave += new Crownwood::Magic::Controls::WizardControl::WizardPageHandler(this, onControlPageLeave);
EventHandler *cancelHandler = new EventHandler(this, onCancelClicked);
wizardControl->CancelClick += cancelHandler;
wizardControl->CloseClick += cancelHandler;
wizardControl->FinishClick += new EventHandler(this, onFinishClicked);
this->Controls->Add(wizardControl);
this->Size = System::Drawing::Size(896, 550);
this->StartPosition = FormStartPosition::CenterScreen;
this->MaximizeBox = false;
this->MinimizeBox = false;
this->SizeGripStyle = SizeGripStyle::Hide;
this->FormBorderStyle = FormBorderStyle::FixedDialog;
}
::CoreLib::System::Object* __array<T>::System_Collections_IList_get_Item(int32_t pos)
{
return __box(this->_data[pos]);
}
//Word separate
void Separate::WordSeparate1(ArrayList* start,ArrayList* end)
{
ArrayList** wordStart=new ArrayList*();
ArrayList** wordEnd=new ArrayList*();
IEnumerator *wordStartEnumerator,*wordEndEnumerator;
ArrayList** wordStart1=new ArrayList*();
ArrayList** wordEnd1=new ArrayList*();
//IEnumerator *wordStartEnumerator1,*wordEndEnumerator1;
//This Function Needs to be upgraded
IEnumerator *startEnumerator;
IEnumerator *endEnumerator;
int start_of_word2=0;
int end_of_word1=0;
int _sum_word_gap=0;
int _number_of_gaps=0;
startEnumerator=start->GetEnumerator(); //linestart (from Separate )
endEnumerator=end->GetEnumerator(); // lineEnd (from Separate)
Vertical=new int*[numberOfLines];
int verticalCount=0;
while(startEnumerator->MoveNext() && endEnumerator->MoveNext())
{
int y1=*dynamic_cast<__box int*> (startEnumerator->Current);
int y2=*dynamic_cast<__box int*> (endEnumerator->Current);
Vertical[verticalCount]=new int[xSize];
for(int i=0;i<this->xSize;i++)
{
int count=0;
for(int j=y1;j<=y2;j++)
{
if(BinaryArray[j][i]==false)
{
count++;
}
}
this->Vertical[verticalCount][i]=count;
}
verticalCount++;
}
//Pen* p=new Pen(Color::Red,1);
int cnt=0;
startEnumerator=start->GetEnumerator();
endEnumerator=end->GetEnumerator();
while(startEnumerator->MoveNext() && endEnumerator->MoveNext())
{
int y1=*dynamic_cast<__box int*> (startEnumerator->Current);
int y2=*dynamic_cast<__box int*> (endEnumerator->Current);
wordStart[cnt]=new ArrayList();
wordEnd[cnt]=new ArrayList();
bool hasWordStarted=false;
for(int j=0;j<this->xSize;j++)
{
if(hasWordStarted==false)
{
if(Vertical[cnt][j]>0)
{
wordStart[cnt]->Add(__box(j));
hasWordStarted=true;
}
}
else
{
if(Vertical[cnt][j]<=0)
{
wordEnd[cnt]->Add(__box(j));
hasWordStarted=false;
}
}
}
wordStartEnumerator=wordStart[cnt]->GetEnumerator();
wordEndEnumerator=wordEnd[cnt]->GetEnumerator();
int no_of_word=0;
while (wordStartEnumerator->MoveNext() && wordEndEnumerator->MoveNext())
{
int x1 = *dynamic_cast<__box int*>(wordStartEnumerator->Current);
int x2 = *dynamic_cast<__box int*>(wordEndEnumerator->Current);
if(no_of_word==0)
{
end_of_word1=x2;
}
else
{
start_of_word2=x1;
_sum_word_gap+=(start_of_word2-end_of_word1);
end_of_word1=x2;
_number_of_gaps++;
}
no_of_word++;
}
cnt++;
}
if(_number_of_gaps==0){
System::Windows::Forms::MessageBox::Show("It seems that gaps between words is invalid \n Please reload a proper image ....","invalid image width");
}
int _average_word_gaps=(int)(_sum_word_gap)/(_number_of_gaps);
//System::Windows::Forms::MessageBox::Show(_average_word_gaps.ToString(),"Average Word Gaps");
cnt=0;
startEnumerator=start->GetEnumerator();
endEnumerator=end->GetEnumerator();
while(startEnumerator->MoveNext() && endEnumerator->MoveNext())
{
int y1=*dynamic_cast<__box int*> (startEnumerator->Current);
int y2=*dynamic_cast<__box int*> (endEnumerator->Current);
wordStartEnumerator=wordStart[cnt]->GetEnumerator();
wordEndEnumerator=wordEnd[cnt]->GetEnumerator();
int word_count=0;
int newx1,newx2,tempx2;
wordStart1[cnt]=new ArrayList();
wordEnd1[cnt]=new ArrayList();
while (wordStartEnumerator->MoveNext() && wordEndEnumerator->MoveNext())
{
int x1 = *dynamic_cast<__box int*>(wordStartEnumerator->Current);
int x2 = *dynamic_cast<__box int*>(wordEndEnumerator->Current);
if(word_count==0)
{
newx1=x1;
tempx2=x2;
}
else
{
if(x1-tempx2>=_average_word_gaps) //the word gap is ge 5
{
newx2=tempx2;
wordStart1[cnt]->Add(__box(newx1));
wordEnd1[cnt]->Add(__box(newx2));
//add newx1 in wordStart1
//add newx2 in wordEnd1
newx1=x1;
tempx2=x2;
}
else //the word gap is l 5 i.e no word is still formed
{
tempx2=x2;
}
}
word_count++;
}
newx2=tempx2;
wordStart1[cnt]->Add(__box(newx1));
wordEnd1[cnt]->Add(__box(newx2));
cnt++;
}
CheckMattra(start,end,wordStart1,wordEnd1);
}
//*************************************************************************
// Method: ScheduledTestPane
// Description: Constructor for the ScheduledTestPane class
//
// Parameters:
// dataArray - the dataArray that this pane should be associated with
// threadID - the thread which the pane belongs to, 0 signifies an all
// process pane.
//
// Return Value: None
//*************************************************************************
ScheduledTestPane::ScheduledTestPane(ScheduledTestDataArray *dataArray, unsigned int ThreadID)
{
uiEventRegistry = UIEventRegistry::getInstance();
ArrayList *visibleHeaders;
ColumnHeader *header;
this->dataArray = dataArray;
this->threadID = ThreadID;
if (threadID != 0)
this->perThreadMode = true;
else
this->perThreadMode = false;
addedDelegate = new ItemAddedDelegate(this, onItemAdded);
deletedDelegate = new ItemDeletedDelegate(this, onItemDeleted);
this->dataArray->onItemAdded += addedDelegate;
this->dataArray->onItemDeleted += deletedDelegate;
ItemCheckEventHandler *listView_ItemCheckEventHandler = new ItemCheckEventHandler (this, listView_ItemCheckEvent);
// create the ListView
listView = new CheckBoxListView();
listView->Dock = DockStyle::Fill;
listView->FullRowSelect = true;
listView->Scrollable = true;
listView->MultiSelect = false;
listView->AllowColumnReorder = true;
allColumns = new ArrayList();
onOffHeader = new ColumnHeader();
onOffHeader->Text = "On/Off";
onOffHeader->Width = 50;
targetThreadHeader = new ColumnHeader();
targetThreadHeader->Text = "Target Thread";
targetThreadHeader->Width = 80;
functionNameHeader = new ColumnHeader();
functionNameHeader->Text = "Function";
functionNameHeader->Width = 140;
returnValueHeader = new ColumnHeader();
returnValueHeader->Text = "Return Value";
returnValueHeader->Width = 80;
errorCodeHeader = new ColumnHeader();
errorCodeHeader->Text = "Error Code";
errorCodeHeader->Width = 140;
matchParamHeader = new ColumnHeader();
matchParamHeader->Text = "In Parameters To Match";
matchParamHeader->Width = 200;
changeParamHeader = new ColumnHeader();
changeParamHeader->Text = "Out Parameters To Change";
changeParamHeader->Width = 200;
testOwnerHeader = new ColumnHeader();
testOwnerHeader->Text = "Owner";
testOwnerHeader->Width = 200;
pauseAfterTestHeader = new ColumnHeader();
pauseAfterTestHeader->Text = "Pause";
pauseAfterTestHeader->Width = 80;
fireConditionHeader = new ColumnHeader();
fireConditionHeader->Text = "Fire Condition";
fireConditionHeader->Width = 210;
listView->Columns->Add(onOffHeader);
listView->Columns->Add(targetThreadHeader);
listView->Columns->Add(functionNameHeader);
listView->Columns->Add(returnValueHeader);
listView->Columns->Add(errorCodeHeader);
listView->Columns->Add(matchParamHeader);
listView->Columns->Add(changeParamHeader);
listView->Columns->Add(testOwnerHeader);
listView->Columns->Add(pauseAfterTestHeader);
listView->Columns->Add(fireConditionHeader);
allColumns->Add(onOffHeader);
allColumns->Add(targetThreadHeader);
allColumns->Add(functionNameHeader);
allColumns->Add(returnValueHeader);
allColumns->Add(errorCodeHeader);
allColumns->Add(matchParamHeader);
allColumns->Add(changeParamHeader);
allColumns->Add(testOwnerHeader);
allColumns->Add(pauseAfterTestHeader);
allColumns->Add(fireConditionHeader);
this->Controls->Add(listView);
LoadSettings(PaneName);
visibleHeaders = this->VisibleColumns;
if (!visibleHeaders)
return;
for (int i=0; i<visibleHeaders->Count; i++)
{
header = dynamic_cast <ColumnHeader*> (visibleHeaders->Item[i]);
// if per-thread setting, then hide threadID column
if ( (perThreadMode) && (header == targetThreadHeader) )
visibleHeaders->Remove(header);
}
this->VisibleColumns = visibleHeaders;
this->listView->MouseUp += new MouseEventHandler(this, onMouseUp);
this->listView->KeyDown += new KeyEventHandler(this, onKeyDown);
this->listView->DoubleClick += new EventHandler(this, onDoubleClick);
this->listView->ContextMenu = new System::Windows::Forms::ContextMenu();
this->listView->SelectedIndexChanged += new EventHandler(this, onSelectedIndexChanged);
allColumnWidths = new ArrayList();
IEnumerator *enumerator = AllColumns->GetEnumerator();
while (enumerator->MoveNext())
{
ColumnHeader *header = dynamic_cast<ColumnHeader *>(enumerator->Current);
if (header == NULL)
continue;
allColumnWidths->Add(__box(header->Width));
}
catchCheckEvent = true;
this->listView->ItemCheck += listView_ItemCheckEventHandler;
}
//*************************************************************************
// Method: set_VisibleColumns
// Description: set method of the VisibleColumns property
//
// Parameters:
// headers - the column headers to set
//
// Return Value: None
//*************************************************************************
void ScheduledTestPane::set_VisibleColumns(ArrayList *headers)
{
if (headers == NULL)
return;
// remove the columns that should not be here
IEnumerator *enumerator = AllColumns->GetEnumerator();
while (enumerator->MoveNext())
{
ColumnHeader *header = dynamic_cast<ColumnHeader *>(enumerator->Current);
if (header == NULL)
continue;
if (listView->Columns->Contains(header))
{
if (!headers->Contains(header))
{
if (allColumnWidths)
allColumnWidths->set_Item(AllColumns->IndexOf(header), __box(header->Width));
// listview has the column, new columns array does not. remove the column
listView->Columns->Remove(header);
}
}
}
// add the columns that should be here
enumerator = AllColumns->GetEnumerator();
while (enumerator->MoveNext())
{
ColumnHeader *header = dynamic_cast<ColumnHeader *>(enumerator->Current);
if (header == NULL)
continue;
if (!listView->Columns->Contains(header))
{
if (headers->Contains(header))
{
// listview does not have the column, but new columns array does. add the column
// try to put it back in the right place. Note
// reordering before the hide and re-show is ignored.
// try to figure out where to insert the column
int i = AllColumns->IndexOf(header);
int insertLocation = i;
int count = 0;
ColumnHeader *colHeader = NULL;
IEnumerator *colEnumerator = AllColumns->GetEnumerator();
while ((colEnumerator->MoveNext()) && (count <= i))
{
colHeader = dynamic_cast<ColumnHeader *>(colEnumerator->Current);
if (((colHeader == NULL) || (!listView->Columns->Contains(colHeader))) && (count != i))
insertLocation--;
count++;
}
if (colHeader != NULL)
{
if (allColumnWidths)
colHeader->Width = *dynamic_cast<__box int *>(allColumnWidths->get_Item(i));
// insert the column header
listView->Columns->Insert(insertLocation, colHeader);
}
}
}
}
enumerator = listView->Items->GetEnumerator();
while (enumerator->MoveNext())
{
ListViewItem *item = dynamic_cast<ListViewItem *>(enumerator->Current);
if (!item)
continue;
UpdateListViewItemStrings(item);
}
}
//WordSeparate is used to separate words
void Separate::WordSeparate(ArrayList* start,ArrayList* end)
{
//System::Windows::Forms::MessageBox::Show(numberOfLines.ToString(),"Total Number Of Lines");
IEnumerator *startEnumerator;
IEnumerator *endEnumerator;
startEnumerator=start->GetEnumerator();
endEnumerator=end->GetEnumerator();
Vertical=new int*[numberOfLines];
int verticalCount=0;
while(startEnumerator->MoveNext() && endEnumerator->MoveNext())
{
int y1=*dynamic_cast<__box int*> (startEnumerator->Current);
int y2=*dynamic_cast<__box int*> (endEnumerator->Current);
Vertical[verticalCount]=new int[xSize];
//System::Windows::Forms::MessageBox::Show(y1.ToString(),"Y1 Value");
//System::Windows::Forms::MessageBox::Show(y2.ToString(),"Y2 Value");
for(int i=0;i<this->xSize;i++)
{
int count=0;
for(int j=y1;j<=y2;j++)
{
//System::Windows::Forms::MessageBox::Show(this->BinaryArray[i][j].ToString(),"Binary Value");
if(BinaryArray[j][i]==false)
{
count++;
}
}
this->Vertical[verticalCount][i]=count;
}
verticalCount++;
}
Pen* p=new Pen(Color::Red,1);
int cnt=0;
startEnumerator=start->GetEnumerator();
endEnumerator=end->GetEnumerator();
int start_of_word=0;
int end_of_word=0;
int _sum_word_length=0;
int _number_of_words=0;
while(startEnumerator->MoveNext() && endEnumerator->MoveNext())
{
int y1=*dynamic_cast<__box int*> (startEnumerator->Current);
int y2=*dynamic_cast<__box int*> (endEnumerator->Current);
ArrayList* wordStart=new ArrayList();
ArrayList* wordEnd=new ArrayList();
IEnumerator *wordStartEnumerator,*wordEndEnumerator;
bool hasWordStarted=false;
for(int j=0;j<this->xSize;j++)
{
if(hasWordStarted==false)
{
if(Vertical[cnt][j]>0)
{
wordStart->Add(__box(j));
hasWordStarted=true;
}
}
else
{
if(Vertical[cnt][j]<=0)
{
wordEnd->Add(__box(j));
hasWordStarted=false;
}
}
}
wordStartEnumerator=wordStart->GetEnumerator();
wordEndEnumerator=wordEnd->GetEnumerator();
while (wordStartEnumerator->MoveNext() && wordEndEnumerator->MoveNext())
{
int x1 = *dynamic_cast<__box int*>(wordStartEnumerator->Current);
int x2 = *dynamic_cast<__box int*>(wordEndEnumerator->Current);
start_of_word=x1;
end_of_word=x2;
_sum_word_length+=(end_of_word-start_of_word);
_number_of_words++;
g->DrawLine(p,x1,y1,x1,y2);
g->DrawLine(p,x2,y1,x2,y2);
}
cnt++;
}
int _average_word_length=(int) (_sum_word_length) / (_number_of_words);
System::Windows::Forms::MessageBox::Show(_average_word_length.ToString(),"Average Word Length");
}
//This is a function which separates lines
void Separate::LineSeparate()
{
ArrayList* lineStart=new ArrayList();
ArrayList* lineEnd=new ArrayList();
// vector <int> lineStart;
// vector <int> lineEnd;
/////
IEnumerator* startEnumerator;
IEnumerator* endEnumerator;
for(int i=0;i<this->ySize;i++)
{
int count=0;
for(int j=0;j<this->xSize;j++)
{
if(this->BinaryArray[i][j]==false)
{
count++;
}
}
this->Horizontal[i]=count;
}
bool hasLineStarted=false;
for(int i=0;i<this->ySize;i++)
{
if(hasLineStarted==false)
{
if(this->Horizontal[i]>0)
{
lineStart->Add(__box(i));
hasLineStarted=true;
}
}
else
{
if(this->Horizontal[i]<=0)
{
lineEnd->Add(__box(i-1));
hasLineStarted=false;
}
}
}
startEnumerator = lineStart->GetEnumerator();
endEnumerator = lineEnd->GetEnumerator();
//Red Pen are used to draw lines when they are separated
Pen* p=new Pen(Color::Red,1);
while (startEnumerator->MoveNext() && endEnumerator->MoveNext())
{ //possible error because startenumerator and endenumerator might not be same.
int s = *dynamic_cast<__box int*>(startEnumerator->Current);
int e = *dynamic_cast<__box int*>(endEnumerator->Current);
numberOfLines++;
g->DrawLine(p,0,s,this->xSize,s);
g->DrawLine(p,0,e,this->xSize,e);
}
this->HeadBottom=new int*[this->numberOfLines];
for(int i=0;i<this->numberOfLines;i++)
{
this->HeadBottom[i]=new int[2];
}
//System::Windows::Forms::MessageBox::Show("ok");
WordSeparate1(lineStart,lineEnd);
}
//*************************************************************************
// Method: GetTreeListNodeFromIndexerNode
// Description: Returns a treelistnode object representing the specified
// indexer node
//
// Parameters:
// currNode - the indexer node to get the treelistnode object for
//
// Return Value: the treelistnode object, NULL if unsuccessful
//*************************************************************************
TreeListNode *LogPaneDataArray::GetTreeListNodeFromIndexerNode(IndexerNode* currNode)
{
if (!currNode || !indexer)
return NULL;
if (currNode == rootNode)
{
TreeListNode *retVal = new TreeListNode();
retVal->Text = "Root";
retVal->IsExpanded = currNode->nodeInfo.expanded;
retVal->Selected = currNode->nodeInfo.selected;
retVal->Focused = currNode->nodeInfo.focused;
retVal->IsVisible = true;
retVal->Tag = __box(UIntPtr(currNode));
InitTreeListNodeDelegates(retVal);
return retVal;
}
LogItem *logItem = indexer->GetLogEntryFromNode(currNode);
if (!logItem)
return NULL;
TreeListNode *retVal = new TreeListNode();
retVal->Text = logItem->TimeStamp;
retVal->SubItems->Add(logItem->ThreadID);
retVal->SubItems->Add(logItem->Category);
retVal->SubItems->Add(logItem->DllName);
retVal->SubItems->Add(logItem->Function);
retVal->SubItems->Add(logItem->ReturnValue->Replace("\n", " "));
//.net gives UINT -1 for errorcode, this should be ignored
if (logItem->ErrorCode->CompareTo("4294967295") != 0)
{
String *ecString = ErrorCodeDB::GetInstance()->GetStringFromCode(logItem->ErrorCode);
if (ecString)
retVal->SubItems->Add(ecString);
else
retVal->SubItems->Add(logItem->ErrorCode);
}
else
{
// Add an empty string to the errorcode column for .NET
retVal->SubItems->Add("");
}
retVal->SubItems->Add(logItem->Exception);
for (int i = 0; i < logItem->Parameters->Count; i++)
{
retVal->SubItems->Add(dynamic_cast<String *>(logItem->Parameters->get_Item(i))->Replace("\n", " "));
}
retVal->Tag = __box(UIntPtr(currNode));
retVal->IsExpanded = currNode->nodeInfo.expanded;
retVal->Selected = currNode->nodeInfo.selected;
retVal->Focused = currNode->nodeInfo.focused;
retVal->UseItemStyleForSubItems = true;
InitTreeListNodeDelegates(retVal);
// don't color the top level nodes, just child nodes
if (currNode->nodeInfo.level > 0)
{
int choice = currNode->nodeInfo.level - 1;
switch(choice)
{
case 0:
retVal->BackColor = Color::Pink;
break;
case 1:
retVal->BackColor = Color::MistyRose;
break;
case 2:
retVal->BackColor = Color::LightPink;
break;
}
}
if (logItem->NetworkLogItems->Count > 0)
retVal->ImageIndex = HolodeckGui::LogListViewIconTypes::NetworkLogIcon;
return retVal;
}
// TODO : Missing rules VAL_RULE_D_OBOW!!!
void ValidationMessageInfo::_StaticConstructor()
{
pRuleUriStandardRules = new System::Uri("urn:rules-dvtk:standard");
pRuleUriStrictRules = new System::Uri("urn:rules-dvtk:strict");
//
// Create pre-boxed values to add to hashtable
//
//System::Object __gc* debug = __box(WrappedValidationMessageLevel::Debug);
//System::Object __gc* dicomObjectRelationship = __box(WrappedValidationMessageLevel::DicomObjectRelationship);
//System::Object __gc* dulpStateMachine = __box(WrappedValidationMessageLevel::DulpStateMachine);
System::Object __gc* error = __box(WrappedValidationMessageLevel::Error);
System::Object __gc* information = __box(WrappedValidationMessageLevel::Information);
System::Object __gc* none = __box(WrappedValidationMessageLevel::None);
//System::Object __gc* scripting = __box(WrappedValidationMessageLevel::Scripting);
//System::Object __gc* scriptName = __box(WrappedValidationMessageLevel::ScriptName);
//System::Object __gc* mediaFilename = __box(WrappedValidationMessageLevel::MediaFilename);
//System::Object __gc* wareHouseLabel = __box(WrappedValidationMessageLevel::WareHouseLabel);
System::Object __gc* warning = __box(WrappedValidationMessageLevel::Warning);
pLevelTable = new System::Collections::Hashtable();
pLevelTableStandard = new System::Collections::Hashtable();
pLevelTableStrict = new System::Collections::Hashtable();
//
// Fill hash table with values
//
//pLevelTable->Add(__box(::VAL_RULE_GENERAL_BASE ), none);
//pLevelTable->Add(__box(::VAL_RULE_A_MEDIA_BASE ), none);
//pLevelTable->Add(__box(::VAL_RULE_D_VR_BASE ), none);
//pLevelTable->Add(__box(::VAL_RULE_D_VM_BASE ), none);
//pLevelTable->Add(__box(::VAL_RULE_D_ENCODING_BASE ), none);
//pLevelTable->Add(__box(::VAL_RULE_D_RANGE_BASE ), none);
//pLevelTable->Add(__box(::VAL_RULE_D_PRESENCE_BASE ), none);
//pLevelTable->Add(__box(::VAL_RULE_DEF_COMMAND_BASE ), none);
//pLevelTable->Add(__box(::VAL_RULE_DEF_DEFINITION_BASE ), none);
//pLevelTable->Add(__box(::VAL_RULE_R_REF_BASE ), none);
//pLevelTable->Add(__box(::VAL_RULE_A_QR_BASE ), none);
//pLevelTable->Add(__box(::VAL_RULE_A_WLM_BASE ), none);
//pLevelTable->Add(__box(::VAL_RULE_A_SR_BASE ), none);
//pLevelTable->Add(__box(::VAL_RULE_ACSE_BASE ), none);
//pLevelTable->Add(__box(::VAL_RULE_INTERNAL_ERROR_BASE ), none);
//
// General rules
//
pLevelTable->Add(__box(::VAL_RULE_GENERAL_BASE ), none);
pLevelTable->Add(__box(::VAL_RULE_GENERAL_1 ), error);
//
// Rules regarding VR compatibility with definition file
//
pLevelTable->Add(__box(::VAL_RULE_D_VR_1 ), error);
//
// Rules regarding value multiplicity
//
pLevelTable->Add(__box(::VAL_RULE_D_VM_1 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_VM_2 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_VM_3 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_VM_4 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_VM_5 ), warning);
//
// Rules regarding value encoding
//
// VR AE
//
pLevelTable->Add(__box(::VAL_RULE_D_AE_1 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_AE_2 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_AE_3 ), error);
//
// VR AS
//
pLevelTable->Add(__box(::VAL_RULE_D_AS_1 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_AS_2 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_AS_3 ), error);
//
// VR AT
//
//pLevelTable->Add(__box(::VAL_RULE_D_AT_1 ), error);
//pLevelTable->Add(__box(::VAL_RULE_D_AT_2 ), error);
//pLevelTable->Add(__box(::VAL_RULE_D_AT_3 ), error);
//
// VR CS
//
pLevelTable->Add(__box(::VAL_RULE_D_CS_1 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_CS_2 ), error);
//pLevelTable->Add(__box(::VAL_RULE_D_CS_3 ), error);
//
// VR DA
//
pLevelTable->Add(__box(::VAL_RULE_D_DA_1 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_DA_2 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_DA_3 ), error);
//pLevelTable->Add(__box(::VAL_RULE_D_DA_4 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_DA_5 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_DA_6 ), warning);
pLevelTable->Add(__box(::VAL_RULE_D_DA_7 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_DA_8 ), warning);
//
// VR DS
//
pLevelTable->Add(__box(::VAL_RULE_D_DS_1 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_DS_2 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_DS_3 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_DS_4 ), error);
// VR DT
pLevelTable->Add(__box(::VAL_RULE_D_DT_1 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_DT_2 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_DT_3 ), error);
//pLevelTable->Add(__box(::VAL_RULE_D_DT_4 ), error);
//pLevelTable->Add(__box(::VAL_RULE_D_DT_5 ), error);
//pLevelTable->Add(__box(::VAL_RULE_D_DT_6 ), error);
//
// VR FL
//
//pLevelTable->Add(__box(::VAL_RULE_D_FL_1 ), error);
//pLevelTable->Add(__box(::VAL_RULE_D_FL_2 ), error);
//pLevelTable->Add(__box(::VAL_RULE_D_FL_3 ), error);
//
// VR FD
//
//pLevelTable->Add(__box(::VAL_RULE_D_FD_1 ), error);
//pLevelTable->Add(__box(::VAL_RULE_D_FD_2 ), error);
//pLevelTable->Add(__box(::VAL_RULE_D_FD_3 ), error);
//
// VR IS
//
pLevelTable->Add(__box(::VAL_RULE_D_IS_1 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_IS_2 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_IS_3 ), error);
//
// VR LO
//
pLevelTable->Add(__box(::VAL_RULE_D_LO_1 ), error);
//pLevelTable->Add(__box(::VAL_RULE_D_LO_2 ), error);
//pLevelTable->Add(__box(::VAL_RULE_D_LO_3 ), error);
//
// VR LT
//
pLevelTable->Add(__box(::VAL_RULE_D_LT_1 ), error);
//pLevelTable->Add(__box(::VAL_RULE_D_LT_2 ), error);
//pLevelTable->Add(__box(::VAL_RULE_D_LT_3 ), error);
//
// VR OB/OF/OW
//
pLevelTable->Add(__box(::VAL_RULE_D_OTHER_1 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_OTHER_2 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_OTHER_3 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_OTHER_4 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_OTHER_5 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_OTHER_6 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_OTHER_7 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_OTHER_8 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_OTHER_9 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_OTHER_10 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_OTHER_11 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_OTHER_12 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_OTHER_13 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_OTHER_14 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_OTHER_15 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_OTHER_16 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_OTHER_17 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_OTHER_18 ), information);
pLevelTable->Add(__box(::VAL_RULE_D_OTHER_19 ), information);
pLevelTable->Add(__box(::VAL_RULE_D_OTHER_20 ), error);
//
// VR PN
//
pLevelTable->Add(__box(::VAL_RULE_D_PN_1 ), error);
//pLevelTable->Add(__box(::VAL_RULE_D_PN_2 ), error);
//pLevelTable->Add(__box(::VAL_RULE_D_PN_3 ), error);
//
// VR SH
//
pLevelTable->Add(__box(::VAL_RULE_D_SH_1 ), error);
//pLevelTable->Add(__box(::VAL_RULE_D_SH_2 ), error);
//pLevelTable->Add(__box(::VAL_RULE_D_SH_3 ), error);
//
// VR SL
//
//pLevelTable->Add(__box(::VAL_RULE_D_SL_1 ), error);
//pLevelTable->Add(__box(::VAL_RULE_D_SL_2 ), error);
//pLevelTable->Add(__box(::VAL_RULE_D_SL_3 ), error);
//
// VR SS
//
//pLevelTable->Add(__box(::VAL_RULE_D_SS_1 ), error);
//pLevelTable->Add(__box(::VAL_RULE_D_SS_2 ), error);
//pLevelTable->Add(__box(::VAL_RULE_D_SS_3 ), error);
//
// VR ST
//
pLevelTable->Add(__box(::VAL_RULE_D_ST_1 ), error);
//pLevelTable->Add(__box(::VAL_RULE_D_ST_2 ), error);
//pLevelTable->Add(__box(::VAL_RULE_D_ST_3 ), error);
//
// VR TM
//
pLevelTable->Add(__box(::VAL_RULE_D_TM_1 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_TM_2 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_TM_3 ), error);
//pLevelTable->Add(__box(::VAL_RULE_D_TM_4 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_TM_5 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_TM_6 ), warning);
pLevelTable->Add(__box(::VAL_RULE_D_TM_7 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_TM_8 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_TM_9 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_TM_A ), warning);
//
// VR UI
//
pLevelTable->Add(__box(::VAL_RULE_D_UI_1 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_UI_2 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_UI_3 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_UI_4 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_UI_5 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_UI_6 ), error);
//
// VR UL
//
//pLevelTable->Add(__box(::VAL_RULE_D_UL_1 ), error);
//pLevelTable->Add(__box(::VAL_RULE_D_UL_2 ), error);
//pLevelTable->Add(__box(::VAL_RULE_D_UL_3 ), error);
//
// VR UN
//
//pLevelTable->Add(__box(::VAL_RULE_D_UN_1 ), error);
//pLevelTable->Add(__box(::VAL_RULE_D_UN_2 ), error);
//pLevelTable->Add(__box(::VAL_RULE_D_UN_3 ), error);
//
// VR US
//
//pLevelTable->Add(__box(::VAL_RULE_D_US_1 ), error);
//pLevelTable->Add(__box(::VAL_RULE_D_US_2 ), error);
//pLevelTable->Add(__box(::VAL_RULE_D_US_3 ), error);
//
// VR UT
//
pLevelTable->Add(__box(::VAL_RULE_D_UT_1 ), error);
//pLevelTable->Add(__box(::VAL_RULE_D_UT_2 ), error);
//pLevelTable->Add(__box(::VAL_RULE_D_UT_3 ), error);
//
// VR Extended character set rules
//
pLevelTable->Add(__box(::VAL_RULE_D_EXT_1 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_EXT_2 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_EXT_3 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_EXT_4 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_EXT_5 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_EXT_6 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_EXT_7 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_EXT_8 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_EXT_9 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_EXT_10 ), error);
//
// Rules regarding value range
//
pLevelTable->Add(__box(::VAL_RULE_D_RANGE_1 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_RANGE_2 ), warning);
pLevelTable->Add(__box(::VAL_RULE_D_RANGE_3 ), error);
//
// Rules regarding attribute presence
//
pLevelTable->Add(__box(::VAL_RULE_D_PRESENCE_1 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_PRESENCE_2 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_PRESENCE_3 ), error);
//pLevelTable->Add(__box(::VAL_RULE_D_PRESENCE_4 ), warning);
pLevelTable->Add(__box(::VAL_RULE_D_PRESENCE_5 ), information);
//
//SPLIT: pLevelTable->Add(__box(::VAL_RULE_D_PRESENCE_6 ), error);
//
pLevelTableStandard->Add(__box(::VAL_RULE_D_PRESENCE_6 ), information);
pLevelTableStrict->Add(__box(::VAL_RULE_D_PRESENCE_6 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_PRESENCE_7 ), information);
pLevelTable->Add(__box(::VAL_RULE_D_PRESENCE_8 ), information);
pLevelTable->Add(__box(::VAL_RULE_D_PRESENCE_9 ), warning);
pLevelTable->Add(__box(::VAL_RULE_D_PRESENCE_10 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_PRESENCE_11 ), warning);
pLevelTable->Add(__box(::VAL_RULE_D_PRESENCE_12 ), information);
pLevelTable->Add(__box(::VAL_RULE_D_PRESENCE_13 ), error);
//
// Rules regarding ACSE parameters
//
pLevelTable->Add(__box(::VAL_RULE_D_PARAM_1 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_PARAM_2 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_PARAM_3 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_PARAM_4 ), error);
pLevelTable->Add(__box(::VAL_RULE_D_PARAM_5 ), warning);
pLevelTable->Add(__box(::VAL_RULE_D_PARAM_6 ), warning);
pLevelTable->Add(__box(::VAL_RULE_D_PARAM_7 ), warning);
//
// Rules regarding checks against definition object
//
pLevelTable->Add(__box(::VAL_RULE_DEF_COMMAND_1 ), error);
pLevelTable->Add(__box(::VAL_RULE_DEF_COMMAND_2 ), error);
pLevelTable->Add(__box(::VAL_RULE_DEF_DEFINITION_1 ), error);
pLevelTable->Add(__box(::VAL_RULE_DEF_DEFINITION_2 ), error);
pLevelTable->Add(__box(::VAL_RULE_DEF_DEFINITION_3 ), warning);
pLevelTable->Add(__box(::VAL_RULE_DEF_DEFINITION_4 ), information);
pLevelTable->Add(__box(::VAL_RULE_DEF_DEFINITION_5 ), error);
pLevelTable->Add(__box(::VAL_RULE_DEF_DEFINITION_6 ), information);
//
// Rules regarding the pixel data length
//
pLevelTable->Add(__box(::VAL_RULE_PIXEL_DATA_1 ), error);
pLevelTable->Add(__box(::VAL_RULE_PIXEL_DATA_2 ), error);
pLevelTable->Add(__box(::VAL_RULE_PIXEL_DATA_3 ), error);
pLevelTable->Add(__box(::VAL_RULE_PIXEL_DATA_4 ), error);
pLevelTable->Add(__box(::VAL_RULE_PIXEL_DATA_5 ), error);
pLevelTable->Add(__box(::VAL_RULE_PIXEL_DATA_6 ), error);
//
// Rules regarding checks against the reference ob
//
// Codes have prefix R_
//
// Rules regarding value range
//
pLevelTable->Add(__box(::VAL_RULE_R_VALUE_1 ), error);
pLevelTable->Add(__box(::VAL_RULE_R_VALUE_2 ), warning);
//
// Rules regarding value representation
//
pLevelTable->Add(__box(::VAL_RULE_R_VR_1 ), error);
//
// Rules regarding value multiplicity
//
pLevelTable->Add(__box(::VAL_RULE_R_VM_1 ), error);
//
// Rules regarding attribute presence
//
pLevelTable->Add(__box(::VAL_RULE_R_PRESENCE_1 ), error);
//
// Rules regarding ACSE reference presence
//
pLevelTable->Add(__box(::VAL_RULE_R_PARAM_1 ), warning);
pLevelTable->Add(__box(::VAL_RULE_R_PARAM_2 ), warning);
pLevelTable->Add(__box(::VAL_RULE_R_PARAM_3 ), warning);
//
// Additional validation rules
//
// Codes have prefix A_
//
pLevelTable->Add(__box(::VAL_RULE_A_MEDIA_1 ), error);
pLevelTable->Add(__box(::VAL_RULE_A_MEDIA_2 ), error);
//pLevelTable->Add(__box(::VAL_RULE_A_MEDIA_3 ), error);
pLevelTable->Add(__box(::VAL_RULE_A_MEDIA_4 ), error);
pLevelTable->Add(__box(::VAL_RULE_A_MEDIA_5 ), error);
//pLevelTable->Add(__box(::VAL_RULE_A_MEDIA_6 ), error);
pLevelTable->Add(__box(::VAL_RULE_A_MEDIA_7 ), error);
pLevelTable->Add(__box(::VAL_RULE_A_MEDIA_8 ), warning);
pLevelTable->Add(__box(::VAL_RULE_A_MEDIA_9 ), error);
pLevelTable->Add(__box(::VAL_RULE_A_MEDIA_A ), information);
pLevelTable->Add(__box(::VAL_RULE_A_MEDIA_B ), error);
pLevelTable->Add(__box(::VAL_RULE_A_MEDIA_C ), error);
pLevelTable->Add(__box(::VAL_RULE_A_MEDIA_SOP_1 ), information);
pLevelTable->Add(__box(::VAL_RULE_A_MEDIA_SOP_2 ), warning);
//
// Validation rules specific for Query/Retrieve
//
pLevelTable->Add(__box(::VAL_RULE_A_QR_1 ), warning);
//
// Messages for internal DVT errors.
//
//pLevelTable->Add(__box(::VAL_RULE_INTERNAL_ERROR_1 ), error);
//pLevelTable->Add(__box(::VAL_RULE_UNKNOWN ), error);
}
/*****************************************************************************
* UnfoldedView - displays the unfolded cube in random orientation and layout
*
* The input cube faces are randomized in terms of their orientation and layout
* but the correct edge to edge mapping of the cube faces remains correct. The
* resulting image is then drawn centered relative to the input XY-coordinates.
*
* RETURNS: NA
*/
void CJMCube::ConstructUnfoldedView(int x, int y)
{
Random * rnd = new Random(); // Random number generator
ArrayList * workList = new ArrayList(); // Working array
ArrayList * faceList = new ArrayList(); // Status of picked faces
ArrayList * showList = new ArrayList();
Int32 edgeMap = 0;
Int32 faceMap = 0;
Int32 i;
Int32 face;
Int32 pick;
Bitmap * newList[] = new Bitmap *[NUM_FACES];
// Copy the reference set of cube faces into a working set
for (i = 0; i < NUM_FACES; i++)
{
workList->Add(m_seedList[i]->Clone
(
RectangleF
(
0, 0,
static_cast<float> (m_seedList[i]->Width),
static_cast<float> (m_seedList[i]->Height)
),
Imaging::PixelFormat::DontCare)
);
faceList->Add(__box(Int32(i)));
}
// Randomly select faces and edges to be appended to selection item
for (i = NUM_FACES; i > 0; i--)
{
// If only one face has been selected, the there are constraints on the
// one which of the remaining faces can be selected. For all other cases
// any remaining face is a valid selection.
while (true)
{
pick = ((int) (96 * rnd->NextDouble())) % faceList->Count;
face = *(__try_cast<Int32 *>(faceList->get_Item(pick)));
if ((faceMap ^ m_cubeRules.faceBits[face]) != 0)
{
faceList->RemoveAt(pick); // Remove selected face from list
faceMap |= m_cubeRules.faceBits[face]; // Update included faces
break;
}
}
SAssembly * ta = new SAssembly;
ta->face = face;
// Randomly select a valid edge to mate to assembly
do
{
ta->edge = ((int) (96 * rnd->NextDouble())) % NUM_EDGES;
int chkBit = m_cubeRules.edgeBit[face, ta->edge];
if ((chkBit & edgeMap) != 0)
break;
} while (showList->Count > 0);
edgeMap |= m_cubeRules.edgeBits[face]; // Update included edges
ta->x = x;
ta->y = y;
ta->bmp = __try_cast<Bitmap *> (workList->get_Item(face));
showList->Add(ta);
}
ShowUnfoldedView(showList);
workList->Clear();
faceList->Clear();
}
