wxIAReturnCode wxIASaneProvider::SelectSource(const wxString &name, wxIAUIMode uiMode, wxWindow *parent) { wxCHECK_MSG(Ok(), wxIA_RC_NOTINITIALIZED, _T("wxIASane not valid!")); wxString selName = name; m_selDevice = -1; if (!m_deviceList) GetSourceCount(); if (m_numDevices <= 0) { wxMessageBox(_("No devices available"), wxTheApp->GetAppName(), wxOK | wxICON_EXCLAMATION | wxCENTRE); return wxIA_RC_NOSOURCE; } wxArrayString sources; sources.Alloc(m_numDevices); unsigned int sel = 0; for (unsigned int i = 0; i < m_numDevices; i++) { sources.Add(wxString::Format("%s %s", m_deviceList[i]->vendor, m_deviceList[i]->model)); if (name == wxString(m_deviceList[i]->name).Strip()) sel = i; } if (uiMode == wxIA_UIMODE_NORMAL) { wxSingleChoiceDialog d(parent, _("Available Devices:"), _("Select Source"), sources); d.SetSelection(sel); if(d.ShowModal() != wxID_OK) return wxIA_RC_CANCELLED; sel = d.GetSelection(); selName = wxString(m_deviceList[sel]->name).Strip(); } else if(!(sel <= m_numDevices)) return wxIA_RC_NOSOURCE; SANE_Status rc = m_sane->SaneOpen(selName); if(rc == SANE_STATUS_GOOD) m_selDevice = sel; return MapStatus(rc); }
/** * Function: alarmHandle() * * Description: This function is called at a periodic rate to perform all * required API operations. It implements the functional requirements of the * application mentioned in the header. */ void alarmHandle(int val) { VpStatusType status; VpEventType event; static bool deviceInitialized = FALSE; static uint8 cmpCounter = 0; /* * This loop will query the FXS device for events, and when an event is * found, it will parse the event and perform further operations. */ while(VpGetEvent(&devCtx, &event)) { /* Print the incoming event */ UtilPrintEvent(&event); /* See "../common/utils.c" */ /* * A channel under test should process all line events without * passing the events over to the main event handling loop */ if ((plineCtxUnderTest != NULL) && (plineCtxUnderTest == event.pLineCtx)) { ProcessLineTestEvent(&event); continue; } /* Parse the RESPONSE category */ if (event.eventCategory == VP_EVCAT_RESPONSE) { if(event.eventId == VP_DEV_EVID_DEV_INIT_CMP) { uint8 lineNum = 0; InitSetMasks(); QS_DEBUG("Device Initialization completed\n"); for (; lineNum < NB_LINE; lineNum++) { status = VpSetLineState(&lineCtx[lineNum], VP_LINE_STANDBY); if (status != VP_STATUS_SUCCESS) { QS_DEBUG("Error setting lineNum %i to VP_LINE_STANDBY: %s\n", lineNum, MapStatus(status)); exit(-1); } status = VpCalLine(&lineCtx[lineNum]); QS_DEBUG("Starting Calibration on lineNum %i\n", lineNum); if (status != VP_STATUS_SUCCESS) { QS_DEBUG("Error calling VpCalLine on lineNum %i:: %s\n", lineNum, MapStatus(status)); exit(-1); } } } else if (event.eventId == VP_EVID_CAL_CMP) { if (++cmpCounter == NB_LINE) { deviceInitialized = TRUE; QS_DEBUG("Calibration completed on both lines ... starting Line Test\n\n"); StartLineTest(0, LT_TID_LINE_V); } } } } /* end while(VpGetEvent(&devCtx, &event)) */ return; }
/** * Function: main() * * Description: This function initializes the API and Devices/Lines. * It also starts the "alarmHandle" function to be called at a periodic rate. */ int main(void) { VpStatusType status; struct itimerval timeStruct, timeOldVal; uint8 lineNum = 0; /* ZTAP board initialization (platform specific) */ BoardInit(); /* See "../common/board.c" */ VpSysInit(); /* * The following structure is specific to Linux. It sets up a timed call * to a user specified function. For the purpose of this demo, the timing * is 20mS and the function that will be called is "alarmHandle". The timer * and function call does not start until "setitimer()" and "signal()" are * called (below). */ timeStruct.it_interval.tv_sec = 0L; timeStruct.it_interval.tv_usec = 19990L; timeStruct.it_value.tv_sec = 0L; timeStruct.it_value.tv_usec = 19990L; timeOldVal.it_interval.tv_sec = 0L; timeOldVal.it_interval.tv_usec = 0L; timeOldVal.it_value.tv_sec = 0L; timeOldVal.it_value.tv_usec = 0L; /* Make the objects (1 device, 2 lines) */ #if (SUPPLY_CONFIGURATION == ABS_SUPPLY) status = VpMakeDeviceObject(VP_DEV_886_SERIES, deviceId, &devCtx, &devObj); #else status = VpMakeDeviceObject(VP_DEV_887_SERIES, deviceId, &devCtx, &devObj); #endif if (status != VP_STATUS_SUCCESS) { QS_DEBUG("Error making the device object: %s\n", MapStatus(status)); exit(-1); } for (; lineNum < NB_LINE; lineNum++) { status = VpMakeLineObject(VP_TERM_FXS_LOW_PWR, lineNum, &lineCtx[lineNum], &lineObj[lineNum], &devCtx); if (status != VP_STATUS_SUCCESS) { QS_DEBUG("Error calling VpMakeLineObject on lineNum %i: %s\n", lineNum, MapStatus(status)); exit(-1); } QS_DEBUG("--- Created lineNum %i---\n", lineNum); } /* Start VpInitDevice and wait for the event VP_DEV_EVID_DEV_INIT_CMP */ #if (SUPPLY_CONFIGURATION == FLY_BACK_SUPPLY) status = VpInitDevice(&devCtx, FB_DEV_PROFILE, FB_AC_600_FXS, FB_DC_25MA_CC, FB_RING_25HZ_SINE, VP_PTABLE_NULL, VP_PTABLE_NULL); #elif (SUPPLY_CONFIGURATION == INVERTING_BOOST_SUPPLY) status = VpInitDevice(&devCtx, IB_DEV_PROFILE, IB_AC_600_FXS, IB_DC_25MA_CC, IB_RING_25HZ_SINE, VP_PTABLE_NULL, VP_PTABLE_NULL); #elif (SUPPLY_CONFIGURATION == ABS_SUPPLY) status = VpInitDevice(&devCtx, ABS_DEV_PROFILE, ABS_AC_600_FXS, ABS_DC_23MA_CC, ABS_RING_25HZ_SINE, VP_PTABLE_NULL, VP_PTABLE_NULL); #else #error "SUPPLY_CONFIGURATION is incorrectly set" #endif if (status != VP_STATUS_SUCCESS) { QS_DEBUG("Device not properly initialized: %s\n", MapStatus(status)); exit(-1); } else { QS_DEBUG("\nDevice Initialization started\n"); } /* * The following two function calls were described above as Linux specific. * They are used to call a user defined function at set increments. The * user may have several other methods to perform the same. */ signal(SIGVTALRM, alarmHandle); setitimer(ITIMER_VIRTUAL, &timeStruct, &timeOldVal); /* * Once the "tick" is setup, the main program can enter a "while(1)" loop * and the user specified function will take over the application (with the * help of the Linux OS) */ while(1); return 0; }