#include "stdafx.h"
#include "DICANN.H"

#include "ANNDOC.H"
#include "ANNVVIEW.H"
#include "MainFrm.h"
#include	"PresStateDlg.h"


#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif


/////////////////////////////////////////////////////////////////////////////
// CDicAnnView

IMPLEMENT_DYNCREATE(CDicAnnView, CView)

BEGIN_MESSAGE_MAP(CDicAnnView, CView)
   //{{AFX_MSG_MAP(CDicAnnView)
   ON_WM_CREATE()   
   ON_COMMAND(ID_ALL_ERORRS, OnAllErorrs)
   ON_UPDATE_COMMAND_UI(ID_ALL_ERORRS, OnUpdateAllErorrs)   
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CDicAnnView construction/destruction

CDicAnnView::CDicAnnView()
{
   m_bCOnvertCalled = FALSE;
}

CDicAnnView::~CDicAnnView()
{
	if (m_LAnnWnd.IsAllocated())
	{
		m_LAnnWnd.Free();
	}
	
}

BOOL CDicAnnView::PreCreateWindow(CREATESTRUCT& cs)
{
   // TODO: Modify the Window class or styles here by modifying
   //  the CREATESTRUCT cs

   return CView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CDicAnnView drawing

void CDicAnnView::OnDraw(CDC* pDC)
{
   CDicAnnDoc* pDoc = GetDocument();
   ASSERT_VALID(pDoc);
   // TODO: add draw code for native data here
}

/////////////////////////////////////////////////////////////////////////////
// CDicAnnView diagnostics

#ifdef _DEBUG
void CDicAnnView::AssertValid() const
{
   CView::AssertValid();
}

void CDicAnnView::Dump(CDumpContext& dc) const
{
   CView::Dump(dc);
}

CDicAnnDoc* CDicAnnView::GetDocument() // non-debug version is inline
{
   ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CDicAnnDoc)));
   return (CDicAnnDoc*)m_pDocument;
}
#endif //_DEBUG


/////////////////////////////////////////////////////////////////////////////
// CDicAnnView message handlers



int CDicAnnView::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
   if (CView::OnCreate(lpCreateStruct) == -1)
      return -1;

   HWND hWnd = GetSafeHwnd();
   m_LAnnWnd.SetWndHandle(hWnd);
   
	m_LAnnWnd.EnablePaintWhileLoad(TRUE);
   m_LAnnWnd.EnableCenterOnZoom(FALSE);
   m_LAnnWnd.GetAutomationObject().SetAutoMenuEnabled(FALSE);


	return 0;
}



void CDicAnnView::OnAllErorrs() 
{
   LBase::DisplayErrorList(m_hWnd);    
}

void CDicAnnView::OnUpdateAllErorrs(CCmdUI* pCmdUI) 
{
   // TODO: Add your command update UI handler code here
   pCmdUI->Enable(LBase::GetErrorsNumber());
   
}


void CDicAnnView::OnActivateView(BOOL bActivate, CView* pActivateView, CView* pDeactiveView) 
{
   // TODO: Add your specialized code here and/or call the base class
   if (bActivate==TRUE && pActivateView == this)
   {
      if (m_LAnnWnd.HandlePalette(WM_QUERYNEWPALETTE, 0, 0) == FALSE)
         m_LAnnWnd.Repaint();
   }
   
   CView::OnActivateView(bActivate, pActivateView, pDeactiveView);
}


L_UINT uButtonArray []= 
{     
   ANNTOOL_FREEHAND         ,
   ANNTOOL_HILITE           ,
   ANNTOOL_REDACT           ,   
   ANNTOOL_NOTE             ,
   ANNTOOL_STAMP            ,
   ANNTOOL_BUTTON           ,
   ANNTOOL_HOTSPOT          ,
   ANNTOOL_AUDIO            ,
   ANNTOOL_RULER            ,
   ANNTOOL_CROSSPRODUCT     ,   
   ANNTOOL_PROTRACTOR       ,
   ANNTOOL_VIDEO            ,
   ANNTOOL_PUSHPIN          ,
   ANNTOOL_FREEHANDHOTSPOT  ,      
   ANNTOOL_ENCRYPT          ,   
   ANNTOOL_POLYRULER        ,
   ANNTOOL_RTF              ,
   ANNTOOL_STAMP_FIRST      ,
   ANNTOOL_STAMP_APPROVED   ,
   ANNTOOL_STAMP_ASSIGNED   ,
   ANNTOOL_STAMP_CHECKED    ,
   ANNTOOL_STAMP_CLATPRV    ,
   ANNTOOL_STAMP_COPY       ,
   ANNTOOL_STAMP_DRAFT      ,
   ANNTOOL_STAMP_EXTENDED   ,
   ANNTOOL_STAMP_FAX        ,
   ANNTOOL_STAMP_FAXED      ,
   ANNTOOL_STAMP_IMPORTANT  ,
   ANNTOOL_STAMP_INVOICE    ,
   ANNTOOL_STAMP_NOTICE     ,
   ANNTOOL_STAMP_OFFICIAL   ,
   ANNTOOL_STAMP_ONFILE     ,
   ANNTOOL_STAMP_PAID       ,
   ANNTOOL_STAMP_PASSED     ,
   ANNTOOL_STAMP_PENDING    ,
   ANNTOOL_STAMP_PROCESSED  ,
   ANNTOOL_STAMP_RECEIVED   ,
   ANNTOOL_STAMP_REJECTED   ,
   ANNTOOL_STAMP_RELEASE    ,
   ANNTOOL_STAMP_SENT       ,
   ANNTOOL_STAMP_SHIPPED    ,
   ANNTOOL_STAMP_TOPSECRET  ,
   ANNTOOL_STAMP_URGENT     ,
   ANNTOOL_STAMP_VOID       ,
   ANNTOOL_STAMP_LAST       ,



};
void CDicAnnView::OnInitialUpdate() 
{
      
	CView::OnInitialUpdate();
   m_LAnnWnd.GetContainerObject().SetUserMode(ANNUSER_DESIGN);	
   if (!m_LAnnWnd.GetToolBar().IsCreated())
      m_LAnnWnd.GetToolBar().Create(GetSafeHwnd(), NULL, ANNTOOLALIGN_RIGHT | ANNTOOLALIGN_TOP, FALSE, NULL, NULL);
	if (m_LAnnWnd.GetToolBar().IsCreated())
   {            
      for(L_UINT uButtonInex =0;  uButtonInex < (sizeof(uButtonArray)/sizeof(uButtonArray[0]));uButtonInex++)
      {
         m_LAnnWnd.GetToolBar().SetButtonVisible(uButtonArray[uButtonInex], FALSE);      
      }
      ::ShowWindow(m_LAnnWnd.GetToolBar().GetWndHandle(), SW_SHOW) ;
   }
}

L_VOID CDicAnnView::ConvertLeadToDicom() 
{
	CAnnMyContainer CurContainer;
	CurContainer.Copy(m_LAnnWnd.GetContainerObject());
	CurContainer.m_nObjectCount = 0;
	
   L_INT nRet = CurContainer.Enumerate(ANNFLAG_RECURSE | ANNFLAG_NOTCONTAINER);
	if (nRet != SUCCESS)
	{
		AfxMessageBox("Error converting annotation objects.", MB_OK | MB_ICONERROR);
	}
}

// Free All drawn annotation objects on the LAnnotationWindow
L_VOID CDicAnnView::FreeAllAnnotationObjects()
{
	// Free the drawn objects
	L_INT nRet = L_ANNDESTROY(m_LAnnWnd.GetContainerObject().GetHandle(), ANNFLAG_NOTCONTAINER|ANNFLAG_RECURSE);
}

L_VOID CDicAnnView::GetDICOMObjectsToBeConverted(L_CHAR*	pszImageSOPInsUID)
{
	L_UINT16		         nRet;
	DICOMGRAPHICOBJECT	AnnGraphic;
	DICOMTEXTOBJECT		AnnTextual;
	L_UINT		         uPointsCount;
	L_UINT		         uObjCount;
	pDICOMANNPOINT	      pPoints = NULL;
	L_UINT					i;
	HANNOBJECT				hAnnObject;

	// Free the drawn objects
	nRet = L_ANNDESTROY(m_LAnnWnd.GetContainerObject().GetHandle(), ANNFLAG_NOTCONTAINER|ANNFLAG_RECURSE);
	
	if (!pszImageSOPInsUID)
	{
		return;
	}
	// Check if the image is one of the referenced image sequence items in the PS module
	pDICOMELEMENT pImageElement = GetDocument()->m_CurPSDataSet.GetPresStateImageRefBySOPInstance(pszImageSOPInsUID);
	if (!pImageElement)
	{
		return;
	}

   pDICOMELEMENT pGraphicAnnSQItem = GetDocument()->m_CurPSDataSet.FindFirstGraphicAnnSQItem();
	
	while (pGraphicAnnSQItem)
	{
		pImageElement = GetDocument()->m_CurPSDataSet.GetLayerImageRefElement(pGraphicAnnSQItem, pszImageSOPInsUID);
		if (!pImageElement)
		{
			continue;
		}
		// Searching for all Graphic Objects in the current sequence
		nRet = GetDocument()->m_CurPSDataSet.GetLayerGraphicObjectCount(pGraphicAnnSQItem, &uObjCount);
		if ((uObjCount > 0) && (nRet == DICOM_SUCCESS))
		{
			for (i = 0; i < uObjCount; i++)
			{
				memset(&AnnGraphic, 0, sizeof(DICOMGRAPHICOBJECT));
				nRet = GetDocument()->m_CurPSDataSet.GetGraphicObjPointCount(pGraphicAnnSQItem , i, & uPointsCount);
				if (nRet != DICOM_SUCCESS)
					return;
				if (uPointsCount > 0)
				{
					pPoints = new DICOMANNPOINT[uPointsCount];
					if (!pPoints)
					{
						return;
					}
					AnnGraphic.pAnnPoints = pPoints;
					AnnGraphic.nPointCount = uPointsCount;
					nRet = GetDocument()->m_CurPSDataSet.GetGraphicObjectInfo(pGraphicAnnSQItem , i, &AnnGraphic, sizeof(DICOMGRAPHICOBJECT));
					if (nRet == DICOM_SUCCESS)
					{
						// Convert the object into LEAD
						nRet = GetDocument()->m_CurPSDataSet.ConvertDicomAnnObjToLEADAnnObj(&hAnnObject, &AnnGraphic, NULL);
						if (nRet == DICOM_SUCCESS)
						{
							  // Draw the object
							  DrawLEADObj(hAnnObject);
						}
					}

					// Do something with the points
					if (pPoints)
					{
						delete [] pPoints;
					}

				}
			}
		}
		
		// Searching for all Textual Objects in the current sequence
		nRet = GetDocument()->m_CurPSDataSet.GetLayerTextObjectCount(pGraphicAnnSQItem, &uObjCount);
		if ((uObjCount > 0) && (nRet == DICOM_SUCCESS))
		{
			for (i = 0; i < uObjCount; i++)
			{
				memset(&AnnTextual, 0, sizeof(DICOMTEXTOBJECT));
				nRet = GetDocument()->m_CurPSDataSet.GetTextObjectInfo(pGraphicAnnSQItem, i, &AnnTextual, sizeof(DICOMTEXTOBJECT));
				if (nRet == DICOM_SUCCESS)
				{
					// Convert the object into LEAD
					nRet = GetDocument()->m_CurPSDataSet.ConvertDicomAnnObjToLEADAnnObj(&hAnnObject, NULL, &AnnTextual);
					if (nRet == DICOM_SUCCESS)
					{
						// Draw the object
						DrawLEADObj(hAnnObject);
					}
				}
			}
		}

		
		pGraphicAnnSQItem = GetDocument()->m_CurPSDataSet.FindNextGraphicAnnSQItem(pGraphicAnnSQItem);
	}
}

L_VOID CDicAnnView::DrawLEADObj(HANNOBJECT hAnnObject)
{
	L_INT nRet;

	nRet  = L_ANNINSERT(m_LAnnWnd.GetContainerObject().GetHandle(),hAnnObject, FALSE);

	if(nRet  != SUCCESS)
	{
		MessageBox("Could not load the DICOM annotation object!");
		return;
	}
	/* Invert the foreground color */
   COLORREF ThisColor;
   L_ANNGETFORECOLOR(hAnnObject, &ThisColor);
   L_ANNSETFORECOLOR (hAnnObject, ThisColor ^ 0x00FFFFFF, 0);

	nRet = L_ANNSETVISIBLE(hAnnObject, TRUE, 0, NULL);
}

//------------------ Derived container class functions --------------//
CAnnMyContainer::CAnnMyContainer()
{
   m_nObjectCount = 0;
}

CAnnMyContainer::~CAnnMyContainer()
{
}

L_INT CAnnMyContainer::EnumerateCallBack(HANNOBJECT hAnnObject)
{
   CMainFrame* pMainFrame = (CMainFrame*) AfxGetApp()->m_pMainWnd;
   LDicomDS* pCurDS = &((CDicAnnDoc*) pMainFrame->GetActiveDocument())->m_CurPSDataSet;

   m_nObjectCount++;
	
	// Process the conversion process
	// Determine which item in the Pres State DS, into which, the new objects will be inserted
	pDICOMELEMENT	pElement = pCurDS->FindFirstElement(NULL, TAG_GRAPHIC_ANNOTATION_SEQUENCE, TRUE);
	if (!pElement)
	{
		pElement = pCurDS->InsertElement(NULL, FALSE, TAG_GRAPHIC_ANNOTATION_SEQUENCE, VR_SQ, TRUE, 0);
	}
	
	pDICOMELEMENT pItemElement = pCurDS->GetChildElement(pElement, TRUE);
	if (!pItemElement)
	{
		// Add Item Node
		pItemElement = pCurDS->InsertElement(pElement, TRUE, TAG_ITEM, VR_CS, TRUE, ELEMENT_INDEX_MAX);
		if (!pItemElement)
		{
			AfxMessageBox("Error in converting the object!", MB_OK | MB_ICONERROR);
			return ERROR_FILE_READ 	;
		}
		
		// TAG_TEXT_OBJECT_SEQUENCE
		pElement = pCurDS->InsertElement(pItemElement, TRUE, TAG_TEXT_OBJECT_SEQUENCE, VR_SQ, TRUE, ELEMENT_INDEX_MAX);

		// TAG_GRAPHIC_OBJECT_SEQUENCE
		pElement = pCurDS->InsertElement(pItemElement, TRUE, TAG_GRAPHIC_OBJECT_SEQUENCE, VR_SQ, TRUE, ELEMENT_INDEX_MAX);

		// TAG_REFERENCED_IMAGE_SEQUENCE
		pElement = pCurDS->InsertElement(pItemElement, TRUE, TAG_REFERENCED_IMAGE_SEQUENCE, VR_SQ, TRUE, ELEMENT_INDEX_MAX);

		// TAG_GRAPHIC_LAYER
		pElement = pCurDS->InsertElement(pItemElement, TRUE, TAG_GRAPHIC_LAYER, VR_CS, FALSE, ELEMENT_INDEX_MAX);
		if (pElement)
		{
			pCurDS->SetStringValue(pElement, "LEAD OBJECTS LAYER", 1);
		}

		// Add graphic layer
		DICOMGRAPHICLAYER GraphicLayer;
		memset(&GraphicLayer, 0, sizeof(DICOMGRAPHICLAYER));
		L_INT16 pGrayScle[1];	
		pGrayScle[0] = (L_INT16)65535;
		L_UINT uIndex;

		GraphicLayer.nLayerOrder = 1;
		GraphicLayer.pRGBLayerColors = NULL;
		GraphicLayer.pszLayerDescription = "Layer for LEAD objects";
		GraphicLayer.pszLayerName = "LEAD OBJECTS LAYER";
		GraphicLayer.puGrayscale = pGrayScle;
		GraphicLayer.uStructSize = sizeof(DICOMGRAPHICLAYER);
		pCurDS->CreateLayer(&GraphicLayer, &uIndex);
	}
	
	L_UINT16 nRet = pCurDS->ConvertLEADAnnObjToDicomAnnObjs(hAnnObject, pItemElement, 0);
	
   return SUCCESS ;
}




//------------------ Derived LAnnotationWindow class functions -------------------//
CAnnDemoBitmap::CAnnDemoBitmap()
{
   SetDisplayMode(DISPLAYMODE_SCALETOGRAY|DISPLAYMODE_FAVORBLACK,DISPLAYMODE_SCALETOGRAY);
}
CAnnDemoBitmap::~CAnnDemoBitmap()
{
}

L_VOID    CAnnDemoBitmap::OnAnnEvent(L_UINT uAnnEvent,L_UINT32 lParam)
{
   LAnnotationWindow::OnAnnEvent(uAnnEvent, lParam);
   
   switch (uAnnEvent)
   {
   case LTANNEVENT_INSERT:
      {
         LAnnotation  * pAnnObj;
         
         pAnnObj = LAnnotation::CreateAnnObject((HANNOBJECT) lParam);
         if (pAnnObj->GetType()== ANNOBJECT_BUTTON)
         {
            pAnnObj->SetTag(++m_nButtons, 0);
         }
      }
      break;
   case LTANNEVENT_AUTOCLICKED:
         {
            LAnnotation * pAnnObj;
            char temp[200];

            pAnnObj = LAnnotation::CreateAnnObject((HANNOBJECT) lParam);
            L_UINT32 uTag = pAnnObj->GetTag();

            if (pAnnObj->GetType()== ANNOBJECT_BUTTON)
            {
               wsprintf(temp, "Button with tag %lu was clicked", uTag);
            }
            else
               if (pAnnObj->GetType()== ANNOBJECT_HOTSPOT)
               {
                  wsprintf(temp, "HotSpot with tag %lu was clicked", uTag);
               }
            else
               if (pAnnObj->GetType()== ANNOBJECT_FREEHANDHOTSPOT)
               {
                  wsprintf(temp, "FreehandHotSpot with tag %lu was clicked", uTag);
               }
               else break;
            ::MessageBox(NULL, temp, "Event", MB_OK|MB_ICONINFORMATION);
         }
         break;
   case LTANNEVENT_TOOLCHECKED :
        ToolChecked(lParam);
        break;
   case LTANNEVENT_AUTOENDSET:
         ToolChecked(ANNTOOL_SELECT);
        break;
   case LTANNEVENT_HYPERLINK:
      ::MessageBox(NULL, "Object's hyperlink has been activated!", "WM_LTANNEVENT", MB_OK);
      break;
   }
}


void CAnnDemoBitmap::ToolChecked(UINT uTool)
{
   switch((UINT) uTool)
   {
   case ANNTOOL_LINE:
      m_nAnnObject = IDM_TOOLLINE;
      break;
   case ANNTOOL_RECT:
      m_nAnnObject = IDM_TOOLRECT;
      break;
   case ANNTOOL_ELLIPSE:
      m_nAnnObject = IDM_TOOLELLIPSE;
      break;
   case ANNTOOL_POLYLINE:
      m_nAnnObject = IDM_TOOLPOLYLINE;
      break;
   case ANNTOOL_POLYGON:
      m_nAnnObject = IDM_TOOLPOLYGON;
      break;
   case ANNTOOL_POINTER:
      m_nAnnObject = IDM_TOOLPOINTER;
      break;
   case ANNTOOL_FREEHAND:
      m_nAnnObject = IDM_TOOLFREEHAND;
      break;
   case ANNTOOL_TEXT:
      m_nAnnObject = IDM_TOOLTEXT;
      break;
   case ANNTOOL_POINT:
      m_nAnnObject = IDM_TOOL_POINT;
      break;
   case ANNTOOL_TEXTPOINTER:
      m_nAnnObject = IDM_TOOL_TEXTPOINTER;
      break;
   case ANNTOOL_CURVECLOSED:
      m_nAnnObject = IDM_TOOL_CURVECLOSED;
      break;
   case ANNTOOL_CURVE:
      m_nAnnObject = IDM_TOOL_CURVE;
      break;

      

   default :
      return;
   }
   GetAutomationObject().SetTool(uTool);
   if (GetToolBar().GetToolChecked()!=uTool)
      GetToolBar().SetToolChecked(uTool);
}

UINT CAnnDemoBitmap::GetCurrentObjectID()
{
   return m_nAnnObject;
}