/* Main function. */ int MosMain(void) { MIL_ID MilApplication; MIL_ID MilSystem; MIL_ID MilDigitizer[2]; MIL_ID MilDisplay[2]; MIL_ID MilImageDisp[2]; /* Allocations. */ MappAlloc(M_DEFAULT, &MilApplication); MsysAlloc(MIL_TEXT("M_DEFAULT"), M_DEFAULT, M_DEFAULT, &MilSystem); MdigAlloc(MilSystem, M_DEV0, MIL_TEXT("M_DEFAULT"), M_DEFAULT, &MilDigitizer[0]); MdigAlloc(MilSystem, M_DEV1, MIL_TEXT("M_DEFAULT"), M_DEFAULT, &MilDigitizer[1]); MdispAlloc(MilSystem, M_DEFAULT, MIL_TEXT("M_DEFAULT"), M_DEFAULT, &MilDisplay[0]); MdispAlloc(MilSystem, M_DEFAULT, MIL_TEXT("M_DEFAULT"), M_DEFAULT, &MilDisplay[1]); /* Allocate 2 display buffers and clear them. */ MbufAlloc2d(MilSystem, (MIL_INT)(MdigInquire(MilDigitizer[0], M_SIZE_X, M_NULL)*GRAB_SCALE), (MIL_INT)(MdigInquire(MilDigitizer[0], M_SIZE_Y, M_NULL)*GRAB_SCALE), 8L+M_UNSIGNED, M_IMAGE+M_GRAB+M_PROC+M_DISP, &MilImageDisp[0]); MbufClear(MilImageDisp[0], 0x0); MbufAlloc2d(MilSystem, (MIL_INT)(MdigInquire(MilDigitizer[1], M_SIZE_X, M_NULL)*GRAB_SCALE), (MIL_INT)(MdigInquire(MilDigitizer[1], M_SIZE_Y, M_NULL)*GRAB_SCALE), 8L+M_UNSIGNED, M_IMAGE+M_GRAB+M_PROC+M_DISP, &MilImageDisp[1]); MbufClear(MilImageDisp[1], 0x80); /* Display the buffers. */ MdispSelect(MilDisplay[0], MilImageDisp[0]); MdispSelect(MilDisplay[1], MilImageDisp[1]); /* Grab continuously on displays at the specified scale. */ MdigControl(MilDigitizer[0], M_GRAB_SCALE, GRAB_SCALE); MdigGrabContinuous(MilDigitizer[0],MilImageDisp[0]); MdigControl(MilDigitizer[1], M_GRAB_SCALE, GRAB_SCALE); MdigGrabContinuous(MilDigitizer[1],MilImageDisp[1]); /* Print a message. */ MosPrintf(MIL_TEXT("Press <Enter> to stop continuous grab.\n")); MosGetch(); /* Halt continuous grab. */ MdigHalt(MilDigitizer[0]); MdigHalt(MilDigitizer[1]); /* Print a message. */ MosPrintf(MIL_TEXT("Press <Enter> to end.\n")); MosGetch(); /* Free allocations. */ MbufFree(MilImageDisp[0]); MbufFree(MilImageDisp[1]); MdispFree(MilDisplay[0]); MdispFree(MilDisplay[1]); MdigFree(MilDigitizer[0]); MdigFree(MilDigitizer[1]); MsysFree(MilSystem); MappFree(MilApplication); return 0; }
int MosMain(void) { MIL_ID MilApplication, /* Application Identifier. */ MilSystem, /* System Identifier. */ MilDisplay, /* Display Identifier. */ MilImage; /* Image buffer Identifier. */ long ReturnValue; /* Return Value holder. */ MIL_DOUBLE SynchronousCallTime, /* Timer variable. */ AsynchronousCallTime; /* Timer variable. */ int n; /* Counter. */ /* Allocate application, system and display. */ MappAlloc(M_DEFAULT, &MilApplication); MsysAlloc(SLAVE_SYSTEM_DESCRIPTOR, M_DEF_SYSTEM_NUM, M_SETUP, &MilSystem); MdispAlloc(MilSystem, M_DEV0, MIL_TEXT("M_DEFAULT"), M_DEFAULT, &MilDisplay); /* Restore source image into an automatically allocated image buffer. */ MbufRestore(IMAGE_FILE, MilSystem, &MilImage); /* Uncomment to display the image. */ /* MdispSelect(MilDisplay, MilImage); */ /* Pause */ MosPrintf(MIL_TEXT("\nMIL DTK:\n")); MosPrintf(MIL_TEXT("--------\n\n")); MosPrintf(MIL_TEXT("Custom synchronous and asynchronous MIL functions:\n\n")); MosPrintf(MIL_TEXT("This example times a synchronous and asynchronous custom function call.\n")); MosPrintf(MIL_TEXT("Press a key to continue.\n\n")); MosGetch(); /* Synchronous function call. */ /* -------------------------- */ /* Call the function a first time for more accurate timings later (dll load, ...). */ ReturnValue = SynchronousFunction(MilImage, MilImage, M_DEFAULT); /* Start the timer */ MappTimer(M_TIMER_RESET+M_SYNCHRONOUS, M_NULL); /* Loop many times for more precise timing. */ for (n= 0; n < NB_LOOP; n++) { /* Call the custom MIL synchronous function. */ ReturnValue = SynchronousFunction(MilImage, MilImage, M_DEFAULT); } /* Read the timer. */ MappTimer(M_TIMER_READ+M_SYNCHRONOUS, &SynchronousCallTime); /* Print the synchronous call time. */ MosPrintf(MIL_TEXT("Synchronous function call time: %.1f us.\n"), SynchronousCallTime*1000000/NB_LOOP); /* Asynchronous function call. */ /* --------------------------- */ /* Call the function a first time for more accurate timings later (dll load, ...). */ AsynchronousFunction(MilImage, MilImage, M_DEFAULT); MthrWait(M_DEFAULT, M_THREAD_WAIT, M_NULL); /* Start the timer */ MappTimer(M_TIMER_RESET+M_SYNCHRONOUS, M_NULL); /* Loop many times for more precise timing. */ for (n= 0; n < NB_LOOP; n++) { /* Call the custom MIL asynchronous function. */ AsynchronousFunction(MilImage, MilImage, M_DEFAULT); } /* Read and print the time. */ MappTimer(M_TIMER_READ+M_SYNCHRONOUS, &AsynchronousCallTime); /* Print the asynchronous call time. */ MosPrintf(MIL_TEXT("Asynchronous function call time: %.1f us.\n"), AsynchronousCallTime*1000000/NB_LOOP); MosPrintf(MIL_TEXT("Press a key to terminate.\n\n")); MosGetch(); /* Free all allocations. */ MbufFree(MilImage); MdispFree(MilDisplay); MsysFree(MilSystem); MappFree(MilApplication); return 0; }
ControlImagenes::ControlImagenes() { //Inicilizacion // m_Milsistema = M_NULL; m_Milaplicacion = M_NULL; m_Mildisplay = M_NULL; m_Miloverlay = M_NULL; m_lut_overlay = M_NULL; m_numImagenes = 0; m_nAnchoImagen = -1; m_nAltoImagen = -1; for (int i=0;i<MAX_NUM_IMAGENES;i++) m_Milimagen[i] = M_NULL; m_MilRGB = M_NULL; M_Clasificacion = M_NULL; m_bufClasificacionSelectiva = NULL; m_bDefiniendoArea = false; m_bPintandoRect = false; MappAlloc(M_DEFAULT, &m_Milaplicacion); // Selecciono la aplicación MIL. if ( m_Milaplicacion == M_NULL ) { AfxMessageBox("Error: No se pudo inicilizar MIL", MB_ICONERROR | MB_OK); } // Pregunto al sistema la versión de la librería de control de proceso de imagen //MappInquire(M_VERSION, &m_Milversion); // pruebas MIL 8 // MsysAlloc(M_SYSTEM_METEOR_II_1394, M_DEV0, M_DEFAULT, &M_sistema); // Selecciono un sistema hardware // if ( M_sistema == M_NULL ) { // AfxMessageBox("Error: No se pudo inicilizar MIL", MB_ICONERROR | MB_OK); // } // Display normal para las imágenes adquiridas y procesadas. MdispAlloc(M_DEFAULT_HOST, M_DEFAULT, "M_DEFAULT", M_WINDOWED + M_GDI_OVERLAY, &m_Mildisplay); if ( m_Mildisplay == M_NULL ) { AfxMessageBox("Error: No se pudo inicilizar MIL", MB_ICONERROR | MB_OK); } // El texto tiene color de fondo transparente MgraControl(M_DEFAULT, M_BACKGROUND_MODE, M_TRANSPARENT); // OVERLAY (diferente para MIL 8 y anteriores if (M_MIL_CURRENT_VERSION >= 8.0) { // Inicializar colores para pintar areas m_listaColor[NEGRO_POS] = M_RGB888(NEGRO_R,NEGRO_G,NEGRO_B); m_listaColor[MARRON_POS] = M_RGB888(MARRON_R,MARRON_G,MARRON_B); m_listaColor[ROJO_POS] = M_RGB888(ROJO_R,ROJO_G,ROJO_B); m_listaColor[CYAN_POS] = M_RGB888(CYAN_R,CYAN_G,CYAN_B); m_listaColor[NARANJA_POS] = M_RGB888(NARANJA_R,NARANJA_G,NARANJA_B); m_listaColor[VERDE_POS] = M_RGB888(VERDE_R,VERDE_G,VERDE_B); m_listaColor[AZUL_POS] = M_RGB888(AZUL_R,AZUL_G,AZUL_B); m_listaColor[MORADO_POS] = M_RGB888(MORADO_R,MORADO_G,MORADO_B); m_listaColor[GRIS_POS] = M_RGB888(GRIS_R,GRIS_G,GRIS_B); m_listaColor[ORO_POS] = M_RGB888(ORO_R,ORO_G,ORO_B); m_listaColor[ROSA_POS] = M_RGB888(ROSA_R,ROSA_G,ROSA_B); MdispControl(m_Mildisplay, M_OVERLAY, M_ENABLE); // Establezco TRANSPARENTE como color transparente MdispControl(m_Mildisplay, M_TRANSPARENT_COLOR, TRANSPARENTE); //Tipo de interpolacion para el redimensionamiento de la imagen en el display //Si se activa en MIL 8, quedan lineas de color transparernte en el overlay cuando el zoom no es 1 //MdispControl(m_Mildisplay, M_INTERPOLATION_MODE, M_NEAREST_NEIGHBOR); } else { // Inicializar colores para pintar areas m_listaColor[0] = NEGRO ; m_listaColor[1] = ROJO_OSC ; m_listaColor[2] = ROJO ; m_listaColor[3] = CYAN ; m_listaColor[4] = AMARILLO; m_listaColor[5] = VERDE ; m_listaColor[6] = AZUL ; m_listaColor[7] = MAGENTA_OSC ; m_listaColor[8] = GRIS ; m_listaColor[9] = AMARILLO_OSC ; m_listaColor[10] = GRIS_CLA ; // LUT MbufAllocColor(M_DEFAULT_HOST, 3L, 256L, 1L, 8L+M_UNSIGNED, M_LUT, &m_lut_overlay); if ( m_lut_overlay == M_NULL) { AfxMessageBox("Error: No se pudo inicilizar MIL", MB_ICONERROR | MB_OK); } crea_LUT_overlay(m_lut_overlay, 0); // Genera LUT color y corrección de gamma configura_overlay(m_Mildisplay, M_NULL, &m_Miloverlay, 1); // repartido entre aqui y CargarImagen // M_NULL, antes ponia M_imagen1 que ya no esta disponible en Analisis, seguramente falle // Asocio la LUT de pseudo-color al display de overlay MdispControl(m_Mildisplay, M_OVERLAY_LUT, m_lut_overlay); // Modifico la configuración del display: m_Mildisplay_normal. // - Deshabilito el menú de tareas. // - Deshabilito la barra del título. // - Fijo la posición de la ventana en 0,0. MdispControl(m_Mildisplay, M_WINDOW_MENU_BAR, M_DISABLE); MdispControl(m_Mildisplay, M_WINDOW_TITLE_BAR, M_DISABLE); MdispControl(m_Mildisplay, M_WINDOW_INITIAL_POSITION_X, 0 ); MdispControl(m_Mildisplay, M_WINDOW_INITIAL_POSITION_Y, 0 ); // Establezco TRANSPARENTE como color transparente MdispOverlayKey(m_Mildisplay, M_KEY_ON_COLOR, M_EQUAL, 0xff, TRANSPARENTE); } // Bitmap de fondo para poner siempre que no haya mas imagenes BYTE bBits[] = {0xd8,0xe9,0xec}; m_backgound_bitmap.CreateBitmap(1,1,1,32,bBits); }
/* -------------- */ int MosMain(void) { MIL_ID MilApplication; MIL_ID MilSystem ; MIL_ID MilDigitizer ; MIL_ID MilDisplay ; MIL_ID MilImageDisp ; MIL_ID GrabBufferList[GRAB_BUFFER_NUMBER]; MIL_ID ProcSystemList[PROCESSING_SYSTEM_NUMBER]; MIL_ID SrcProcBufferList[BUFFER_NUMBER]; MIL_ID DstProcBufferList[BUFFER_NUMBER]; MIL_INT SizeX, SizeY, SizeBand; MIL_TEXT_CHAR SystemDescriptor[SYSTEM_DESCRIPTOR_SIZE]; long NbSystem = 0, NbSystemToAllocate = PROCESSING_SYSTEM_NUMBER; MIL_INT GrabFrameCount, n; double SingleSystemProcessingRate, MultipleSystemProcessingRate; ProcessingDataStruct ProcessingData; /* Allocations and setup. */ /* ---------------------- */ /* MIL application allocation. */ MappAlloc(M_DEFAULT, &MilApplication); /* Allocations on the default grab system. */ MsysAlloc(M_SYSTEM_DEFAULT, M_DEFAULT, M_DEFAULT, &MilSystem); MdispAlloc(MilSystem, M_DEV0, MIL_TEXT("M_DEFAULT"), M_DEFAULT, &MilDisplay); MdigAlloc(MilSystem, M_DEV0, MIL_TEXT("M_DEFAULT"), M_DEFAULT, &MilDigitizer); /* Inquire the digitizer's size. */ SizeX = ProcessingData.SizeX = (MIL_INT)(MdigInquire(MilDigitizer, M_SIZE_X, M_NULL)*BUFFER_SCALE); SizeY = ProcessingData.SizeY = (MIL_INT)(MdigInquire(MilDigitizer, M_SIZE_Y, M_NULL)*BUFFER_SCALE); SizeBand = ProcessingData.SizeBand = (MIL_INT)(MdigInquire(MilDigitizer, M_SIZE_BAND, M_NULL)); /* Allocate a display buffer and clear it. */ MbufAllocColor(MilSystem, SizeBand, SizeX, SizeY, 8L+M_UNSIGNED, M_IMAGE+M_GRAB+M_DISP, &MilImageDisp); MbufClear(MilImageDisp, 0x0); /* Display the processing result if activated (might be the limiting factor for speed). */ if (DISPLAY_EACH_IMAGE_PROCESSED) MdispSelect(MilDisplay, MilImageDisp); /* Allocate the grab buffers. */ for (n=0; n< GRAB_BUFFER_NUMBER; n++) MbufAllocColor(MilSystem, SizeBand, SizeX, SizeY, 8L+M_UNSIGNED, M_IMAGE+M_GRAB, &GrabBufferList[n]); /* Allocate and order the required processing systems. */ if (USE_GRAB_SYSTEM_AS_ONE_PROCESSOR) NbSystemToAllocate--; for (n=0; n<NbSystemToAllocate; n++) { /* Create a system descriptor: (Protocol://Address/System (Ex: dmiltcp://127.0.0.1/M_SYSTEM_HOST)) */ MosSprintf(SystemDescriptor, SYSTEM_DESCRIPTOR_SIZE, MT("%s://%s/%s"), DISTRIBUTED_MIL_PROTOCOL, SYSTEM_ADDRESSES[n], PROCESSING_SYSTEM_TYPE); /* Allocate the system. */ MsysAlloc(SystemDescriptor, M_DEFAULT, M_DEFAULT, &ProcSystemList[n]); /* Count the sucessfully allocated processing systems. */ if (ProcSystemList[n]) NbSystem++; } /* If the grab system is used to process, we add it at the end of the processing system list . This permits to dispatch the job to the other remote systems before to use the grab system itself to process synchronously. */ if (USE_GRAB_SYSTEM_AS_ONE_PROCESSOR) { ProcSystemList[NbSystem] = MilSystem; NbSystem++; } /* Allocate and order the source and destination processing buffers alternating the target system. */ for (n=0; n<(NbSystem*BUFFER_PER_PROCESSOR); n++) { MbufAllocColor(ProcSystemList[n%NbSystem], SizeBand, SizeX, SizeY, 8L+M_UNSIGNED, M_IMAGE+M_PROC, &SrcProcBufferList[n]); MbufAllocColor(ProcSystemList[n%NbSystem], SizeBand, SizeX, SizeY, 8L+M_UNSIGNED, M_IMAGE+M_PROC, &DstProcBufferList[n]); } /* Set the specified grab scale. */ MdigControl(MilDigitizer, M_GRAB_SCALE, BUFFER_SCALE); /* Single system processing. */ /* ------------------------- */ /* Print a message. */ /* Print a message. */ MosPrintf(MIL_TEXT("\nDISTRIBUTED MIL PROCESSING:\n")); MosPrintf(MIL_TEXT("---------------------------\n\n")); MosPrintf(MIL_TEXT("1 System processing:\n")); /* Initialize processing variables. */ ProcessingData.NbSystem = 1; ProcessingData.ProcessEachImageOnAllSystems = M_NO; ProcessingData.NbProc = 0; ProcessingData.MilDigitizer = MilDigitizer; ProcessingData.DispBuffer = MilImageDisp; ProcessingData.SrcProcBufferListPtr = SrcProcBufferList; ProcessingData.DstProcBufferListPtr = DstProcBufferList; /* Start processing the buffers. */ MdigProcess(MilDigitizer, GrabBufferList, GRAB_BUFFER_NUMBER, M_START, M_DEFAULT, ProcessingFunction, &ProcessingData); /* Wait for a key and stop the processing. */ MosPrintf(MIL_TEXT("Press <Enter> to stop.\n\n")); MosGetch(); MdigProcess(MilDigitizer, GrabBufferList, GRAB_BUFFER_NUMBER, M_STOP+M_WAIT, M_DEFAULT, ProcessingFunction, &ProcessingData); /* Print statistics. */ if (ProcessingData.NbProc != 0) { SingleSystemProcessingRate = ProcessingData.NbProc/ProcessingData.Time; MdigInquire(MilDigitizer, M_PROCESS_FRAME_COUNT, &GrabFrameCount); MosPrintf(MIL_TEXT("%ld Frames grabbed, %ld Frames processed at %.1f frames/sec (%.1f ms/frame).\n"), GrabFrameCount, ProcessingData.NbProc, SingleSystemProcessingRate, 1000.0/SingleSystemProcessingRate); } else MosPrintf(MIL_TEXT("No frame has been grabbed.\n")); MosPrintf(MIL_TEXT("Press <Enter> to continue.\n\n")); MosGetch(); /* Multiple systems processing. */ /* ---------------------------- */ /* Print a message. */ MosPrintf(MIL_TEXT("%ld Systems processing:\n"), NbSystem); /* Halt continuous grab. */ MdigHalt(MilDigitizer); /* Initialize processing variables. */ ProcessingData.NbSystem = NbSystem; ProcessingData.ProcessEachImageOnAllSystems = PROCESS_EACH_IMAGE_ON_ALL_SYSTEMS; ProcessingData.NbProc = 0; ProcessingData.DispBuffer = MilImageDisp; ProcessingData.SrcProcBufferListPtr = SrcProcBufferList; ProcessingData.DstProcBufferListPtr = DstProcBufferList; /* Start processing the buffers. */ MdigProcess(MilDigitizer, GrabBufferList, GRAB_BUFFER_NUMBER, M_START, M_DEFAULT, ProcessingFunction, &ProcessingData); /* Wait for a key and stop the processing. */ MosPrintf(MIL_TEXT("Press <Enter> to stop.\n\n")); MosGetch(); MdigProcess(MilDigitizer, GrabBufferList, GRAB_BUFFER_NUMBER, M_STOP+M_WAIT, M_DEFAULT, ProcessingFunction, &ProcessingData); /* Print statistics. */ if (ProcessingData.NbProc != 0) { MultipleSystemProcessingRate = ProcessingData.NbProc/ProcessingData.Time; MdigInquire(MilDigitizer, M_PROCESS_FRAME_COUNT, &GrabFrameCount); MosPrintf(MIL_TEXT("%ld Frames grabbed, %ld Frames processed at %.1f frames/sec (%.1f ms/frame).\n\n"), GrabFrameCount, ProcessingData.NbProc, MultipleSystemProcessingRate, 1000.0/MultipleSystemProcessingRate); MosPrintf(MIL_TEXT("Speedup factor: %.1f.\n\n"),MultipleSystemProcessingRate/SingleSystemProcessingRate); if (DISPLAY_EACH_IMAGE_PROCESSED && ((long)((MultipleSystemProcessingRate/SingleSystemProcessingRate)+0.1) < NbSystem)) MosPrintf(MIL_TEXT("Warning: Display might limit the processing speed. Disable it and retry.\n\n")); } else MosPrintf(MIL_TEXT("No frame has been grabbed.\n")); MosPrintf(MIL_TEXT("Press <Enter> to end.\n\n")); MosGetch(); /* Free allocations. */ /* ----------------- */ for (n=0; n<GRAB_BUFFER_NUMBER; n++) MbufFree(GrabBufferList[n]); for (n=0; n<BUFFER_NUMBER; n++) { MbufFree(SrcProcBufferList[n]); MbufFree(DstProcBufferList[n]); } if (USE_GRAB_SYSTEM_AS_ONE_PROCESSOR) NbSystem--; for (n=0; n<NbSystem; n++) MsysFree(ProcSystemList[n]); MbufFree(MilImageDisp); MdispFree(MilDisplay); MdigFree(MilDigitizer); MsysFree(MilSystem); MappFree(MilApplication); return 0; }
void MdispGtkView::Initialize() { // Allocate a display [CALL TO MIL] MdispAlloc(((MdispGtkApp*)dispGtkApp())->m_MilSystem, M_DEFAULT, "M_DEFAULT", M_DEFAULT, &m_MilDisplay); if(m_MilDisplay) { MIL_INT DisplayType = MdispInquire(m_MilDisplay, M_DISPLAY_TYPE, M_NULL); // Check display type [CALL TO MIL] if((DisplayType&(M_WINDOWED|M_EXCLUSIVE)) !=M_WINDOWED) m_isWindowed = false; if(DisplayType&(M_EXCLUSIVE)) m_isExclusive = true; // ROI are supported with windowed display m_isROISupported = (DisplayType&M_WINDOWED) != 0; // Initially set interpolation mode and view mode to default ChangeInterpolationMode(M_DEFAULT); ChangeViewMode(M_DEFAULT); if(m_isWindowed) { #if USE_ANNOTATION // The connection to the X display must be given to Mil so it // can update the window when ROI is enabled MdispControl(m_MilDisplay,M_WINDOW_ANNOTATIONS,M_PTR_TO_DOUBLE(GDK_WINDOW_XDISPLAY(m_window->window))); #else m_isROISupported = false; #endif } if(m_isROISupported) { // Set ROI-show mode. ROIShow(m_isInROIShowMode); // Install hooks for ROI info in status bar and to keep current status // in toolbar MdispHookFunction(m_MilDisplay, M_ROI_CHANGE, ROIChangeFct, (void*)this); MdispHookFunction(m_MilDisplay, M_ROI_CHANGE_END, ROIChangeEndFct, (void*)this); } if(IsNetworkedSystem()) { // Check compression type [CALL TO MIL] MdispInquire(m_MilDisplay, M_COMPRESSION_TYPE, &m_currentCompressionType); // Check asynchronous mode [CALL TO MIL] m_isInAsynchronousMode = (MdispInquire(m_MilDisplay, M_ASYNC_UPDATE, M_NULL) == M_ENABLE); // Check asynchronous frame rate [CALL TO MIL] MdispInquire(m_MilDisplay, M_UPDATE_RATE_MAX, &m_currentAsynchronousFrameRate); // Check Q factor [CALL TO MIL] MdispInquire(m_MilDisplay, M_Q_FACTOR, &m_currentQFactor); } if(m_isExclusive) { MdispInquire(m_MilDisplay, M_RESTRICT_CURSOR, &m_currentRestrictCursor); } //Select the buffer from it's display object and given window [CALL TO MIL] MdispSelectWindow(m_MilDisplay, m_MilImage, m_isWindowed?GDK_WINDOW_XID(m_window->window):0); } // Hook a function to mouse-movement event, to update cursor position in status bar. MdispHookFunction(m_MilDisplay, M_MOUSE_MOVE, MouseFct, (void*)this); ///////////////////////////////////////////////////////////////////////// // MIL: Code that will be executed when a view is first attached to the document ///////////////////////////////////////////////////////////////////////// }