/* 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
/////////////////////////////////////////////////////////////////////////
}
