void msf_send_DispReq(char * displayText, char * callbackNo, PPIDType user, UByte setupSpec)
{
SioMsfInfoReqType * infoReq;
int index = 0;
PMIDType pmid;
int callBackNoLength = 0;
PPID2PMID(&pmid, user);
if (callbackNo != 0) {
callBackNoLength = strlen(callbackNo);
}
NewSignal(sizeof(SignalType) + strlen(displayText) + 1 + 1 + callBackNoLength + 1 + 1, (void**) &infoReq);
infoReq->PpSetup = setupSpec;
memcpy(getSioMsfInfoReqTypeIE(infoReq), displayText, strlen(displayText));
index += strlen(displayText);
getSioMsfInfoReqTypeIE(infoReq)[index++] = 0x00; /*zero terminate string*/
if (callbackNo != 0) {
memcpy(getSioMsfInfoReqTypeIE(infoReq) + index, callbackNo, strlen(callbackNo));
index += strlen(callbackNo);
}
getSioMsfInfoReqTypeIE(infoReq)[index] = 0x00; /*zero terminate string*/
memcpy((UByte*) infoReq->SignalHeader.Address, &pmid, 3);
SendSignal((SignalType *) infoReq, APP_SS_PROCESS_ID, APP_SS_PRIMITIVE, SIO_MSF_INFO_req);
}
UByte voice_disConnectUser(PPIDType user)
{
if (QuickData[user].EmptyMarker == 0) {
ApplicationInstanceType *applicationInstanceData;
PMIDType pmid;
PPID2PMID((PMIDType *) pmid, user);
applicationInstanceData = getApplicationInstance(pmid);
if (applicationInstanceData->state == connected) {
SignalType *CcReleasePrim;
UByte Data[2] = { 0x2e, 00 };
NewSignal(sizeof(SignalType) + 2, (void **) &CcReleasePrim);
memcpy(CcReleasePrim->Address, pmid, 3);
CcReleasePrim->Address[3] = 0x00;
_memcpy(getCcReleasePrimTypeIE(CcReleasePrim), Data, 2);
SendSignal((SignalType *) CcReleasePrim, IWU_PROCESS_ID, IWU_PRIMITIVE, CC_RELEASE_prim);
applicationInstanceData->state = idle;
return 0;
} else {
return 2;
}
} else {
return 3;
}
}
UByte msf_setupreq_format1(PPIDType to, UByte setupSpec1, char * display, PPIDType callbackId)
{
SignalType * signal;
PMIDType pmid;
char callback[12];
if (QuickData[to].EmptyMarker != 0)
return 0;
PPID2PMID(&pmid, to);
memset(callback, 0, 12);
StrPrintHexWord(callback, callbackId);
NewSignal(sizeof(SignalType) + 3 + strlen(display) + strlen(callback), (void**) &signal);
getSignalData(signal)[0] = setupSpec1;
memcpy(getSignalData(signal) + 1, display, strlen(display));
getSignalData(signal)[1 + strlen(display)] = 0;
if (strlen(callback) > 0) {
memcpy(getSignalData(signal) + 1 + strlen(display) + 1, callback, strlen(callback) + 1);
} else {
getSignalData(signal)[1 + strlen(display) + 1] = 0;
}
memcpy(signal->Address, pmid, 3);
SendSignal(signal, APP_SS_PROCESS_ID, APP_SS_PRIMITIVE, SIO_MSF_SETUP_req);
return 1;
}
void handleAPPCCSetupInd(SignalType * TheSignal, ApplicationInstanceType * applicationInstanceData)
{
SignalType *appccSetupAckReqSignal;
char StatusString[256];
char* tmp = StatusString;
tmp = StringPrint(tmp, "\r\nApplication: outgoing call start: Calling party number: ");
tmp = StringPrint(tmp, (char*) (getSignalData(TheSignal) + 1));
PrintStatus(0, StatusString);
applicationInstanceData->state = outgoingcall;
NewSignal(sizeof(SignalType) + 9, (void**) &appccSetupAckReqSignal);
memcpy(appccSetupAckReqSignal->Address, TheSignal->Address, 4);
getSignalData(appccSetupAckReqSignal)[0] = 0x08; /*//info element offset*/
getSignalData(appccSetupAckReqSignal)[1] = 0x01; /*UplaneEndpointStart*/
getSignalData(appccSetupAckReqSignal)[2] = 0x02; /*UplaneEndpointStart*/
getSignalData(appccSetupAckReqSignal)[3] = 0x00; /*UplaneEndpointStart*/
getSignalData(appccSetupAckReqSignal)[4] = 0x00; /*UplaneEndpointStart*/
getSignalData(appccSetupAckReqSignal)[5] = 0x1e;
getSignalData(appccSetupAckReqSignal)[6] = 0x02;
getSignalData(appccSetupAckReqSignal)[7] = 0x85;
getSignalData(appccSetupAckReqSignal)[8] = 0x88;
SendSignal(appccSetupAckReqSignal, APP_CC_PROCESS_ID, APP_CC_PRIMITIVE, APPCCSetupAckReq);
}
static void EEPROMWriteReadTestHandler(SignalType * Signal)
{
switch (Signal->Event)
{
case EE_PRIMITIVE:
switch (Signal->SubEvent)
{
case EE_READ_DATA_cfm:
{
char* ptr;
EeStoreDataReqType *EeStoreDataReq;
ptr = StringPrint(StatusString, "EE_READ_DATA_cfm[");
ptr = StrPrintHexWord(ptr, EEP_UserDataArea);
ptr = StringPrint(ptr, "]=[");
ptr = StrPrintHexByte(ptr, eepromData[0]);
ptr = StringPrint(ptr, "]");
PrintStatus(0, StatusString);
eepromData[0]++;
NewSignal(sizeof(EeStoreDataReqType) + 1, (void **) &EeStoreDataReq);
getSignalData(EeStoreDataReq)[0] = eepromData[0];
EeStoreDataReq->DataTypes = EEDT_ANYADDRESS;
EeStoreDataReq->SubsNo = 0;
setAddressData(EEP_UserDataArea, 1);
SendSignal((SignalType *) EeStoreDataReq, EE_PROCESS_ID, EE_PRIMITIVE, EE_STORE_DATA_req);
setSignalHandler(APPLICATION_PROCESS_ID_PP, PPconnectionHandler, 0);
}
break;
}
}
DeleteBuffer(Signal);
}
UByte voice_callUser(PPIDType called, PPIDType caller)
{
ApplicationInstanceType *applicationInstanceData;
if (QuickData[called].EmptyMarker == 0) {
SignalType * signal;
NewSignal(sizeof(SignalType), (void**) &signal);
PPID2PMID((PMIDType *) signal->Address, called);
applicationInstanceData = getApplicationInstance(signal->Address);
if (applicationInstanceData->state == idle) {
applicationInstanceData->state = incommingcall;
applicationInstanceData->connectedTo = caller;
SendSignal((SignalType*) signal, APP_CC_PROCESS_ID, APP_CC_PRIMITIVE, APPCCSetupReq);
/*setup the outgoing side of the call:*/
{
PMIDType pmid;
char tmp[13];
UByte sum = called;
PPID2PMID(&pmid, caller);
applicationInstanceData = getApplicationInstance(pmid);
applicationInstanceData->connectedTo = called;
memset(tmp, 0, 12);
tmp[0] = sum + '0';
handleConnectPrim(pmid, applicationInstanceData);
/*{
AudioLineCtrlReqType *AudioLineCtrlReq;
NewSignal(sizeof(AudioLineCtrlReqType), (void **) &AudioLineCtrlReq);
AudioLineCtrlReq->TheSignal.Address[0] = 0x0F;
AudioLineCtrlReq->TheSignal.Address[1] = 0;//MeInstance->Mcei;
AudioLineCtrlReq->Lid = sum;
_memcpy(AudioLineCtrlReq->Pmid,pmid,3);
AudioLineCtrlReq->option = 3;
PrintStatus(0, "\r\napp: send AUDIOLINECTRL_req to mac layer");
SendSignal((SignalType*)AudioLineCtrlReq, CCF_PROCESS_ID, CCF_PRIMITIVE, AUDIOLINECTRL_req);
}*/
}
return 1;
} else {
DeleteBuffer(signal);
PrintStatus(0, "\r\nnumber found, but user allready active.\n");
return 2;
}
} else {
PrintStatus(0, "\r\nnumber not found...");
return 3;
}
}
UByte msf_send_CONNECT_res(PPIDType user)
{
SignalType * signal;
PMIDType pmid;
getApplicationInstanceData(user)->msfState = msf_connected;
NewSignal(sizeof(SignalType) + 2, (void**) &signal);
PPID2PMID(&pmid, user);
memcpy(signal->Address, pmid, sizeof(PMIDType));
SendSignal(signal, APP_SS_PROCESS_ID, APP_SS_PRIMITIVE, SIO_MSF_CONNECT_res);
return 1;
}
void handleConnectPrim(PMIDType pmid, ApplicationInstanceType * applicationInstanceData)
{
SignalType *ccconnectSignal;
NewSignal(sizeof(SignalType) + 5, (void**) &ccconnectSignal);
memcpy(ccconnectSignal->Address, pmid, 3); /*pmid in address field*/
getSignalData(ccconnectSignal)[0] = 0x05; /*info element offset*/
getSignalData(ccconnectSignal)[1] = 0x01; /*UplaneEndpointStart*/
getSignalData(ccconnectSignal)[2] = 0x02; /*UplaneEndpointStart*/
getSignalData(ccconnectSignal)[3] = 0x00; /*UplaneEndpointStart*/
getSignalData(ccconnectSignal)[4] = 0x00; /*UplaneEndpointStart*/
applicationInstanceData->state = connected;
SendSignal(ccconnectSignal, APP_CC_PROCESS_ID, APP_CC_PRIMITIVE, APPCCConnectAckReq);
}
UByte msf_send_ReleaseReq(PPIDType user, UByte releaseReason)
{
SignalType * signal;
PMIDType pmid;
if (QuickData[user].EmptyMarker != 0)
return 0;
getApplicationInstanceData(user)->msfState = msf_release_pending;
NewSignal(sizeof(SignalType) + 1, (void**) &signal);
getSignalData(signal)[0] = releaseReason;
PPID2PMID(&pmid, user);
memcpy(signal->Address, pmid, sizeof(PMIDType));
SendSignal(signal, APP_SS_PROCESS_ID, APP_SS_PRIMITIVE, SIO_MSF_RELEASE_req);
return 1;
}
static void PPDialingHandler(SignalType * Signal)
{
switch (Signal->Event)
{
case IWU_PRIMITIVE:
{
switch (Signal->SubEvent)
{
case CC_CONNECT_prim:
{
SignalType * startAudio;
NewBuffer(sizeof(SignalType), (void**) &startAudio);
SendSignal((SignalType*) startAudio, DSP_PROCESS_ID, SETUPAUDIO_EVENT, 0);
connected = 1;
}
case CC_INFO_prim: /*do not break*/
{
if (connected == 1) {
SignalType* mySignal;
NewSignal(sizeof(SignalType) + 2 + strlen(numberToDial), (void **) &mySignal);
getSignalData(mySignal)[0] = 0x2c;
getSignalData(mySignal)[1] = strlen(numberToDial);
memcpy(getSignalData(mySignal) + 2, numberToDial, strlen(numberToDial));
InjectSignal(mySignal, IWU_PROCESS_ID, IWU_PRIMITIVE, CC_INFO_prim, Signal->SessionId);
}
}
break;
case CC_RELEASE_prim:
{
if (connected == 1) {
Signal->SignalLength = sizeof(CcReleaseComPrimType);
SendSignal(Signal, IWU_PROCESS_ID, IWU_PRIMITIVE, CC_RELEASE_COM_prim);
connected = 0;
setSignalHandler(APPLICATION_PROCESS_ID_PP, PPconnectionHandler, 0);
return;
}
}
break;
}
}
}
DeleteBuffer(Signal);
}
UByte fp_send_module2module(PPIDType user, module2moduleData data)
{
SsFacilityPrimType * SsFacilityPrim;
UByte * dst;
UByte cnt;
NewSignal(sizeof(SsFacilityPrimType) + 5, (void**) &SsFacilityPrim);
dst = (UByte *) getSsFacilityPrimTypeIE(SsFacilityPrim);
dst[0] = MODULE_SHORT_MSF;
for (cnt = 1; cnt <= 3; cnt++)
dst[cnt] = data[cnt - 1];
PPID2PMID((PMIDType*) SsFacilityPrim->SignalHeader.Address, user);
SendSignal((SignalType*) SsFacilityPrim, IWU_PROCESS_ID, IWU_PRIMITIVE, SS_TUNNEL_prim);
return 0;
}
UByte msf_send_ppstatusReq(PPIDType to, UByte statusType, UByte * data, UByte dataLength)
{
SignalType * signal;
PMIDType pmid;
if (QuickData[to].EmptyMarker != 0)
return 1;
if (dataLength > 100)
return 2;
PPID2PMID(&pmid, to);
NewSignal(sizeof(SignalType) + 1 + dataLength, (void**) &signal);
getSignalData(signal)[0] = statusType;
memcpy(getSignalData(signal) + 1, data, dataLength);
memcpy(signal->Address, pmid, 3);
SendSignal(signal, APP_SS_PROCESS_ID, APP_SS_PRIMITIVE, SIO_PP_STATUS_req);
return 0;
}
UByte msf_setupreq_format2(PPIDType to, UByte setupSpec1, char * display, PPIDType callbackId, UByte setupSpec2, UByte setupSpec3, alertConstructiontType alertConstruction, UByte displayTimeout, dateAndTimeType dateAndTime)
{
SignalType * signal;
PMIDType pmid;
char callback[12];
UByte index;
if (QuickData[to].EmptyMarker != 0)
return 0;
PPID2PMID(&pmid, to);
memset(callback, 0, 12);
StrPrintHexWord(callback, callbackId);
NewSignal(sizeof(SignalType) + 3 + strlen(display) + strlen(callback) + 6 + 1 + dateAndTime.length, (void**) &signal);
getSignalData(signal)[0] = setupSpec1;
memcpy(getSignalData(signal) + 1, display, strlen(display));
getSignalData(signal)[1 + strlen(display)] = 0;
if (strlen(callback) > 0) {
memcpy(getSignalData(signal) + 1 + strlen(display) + 1, callback, strlen(callback) + 1);
index = 1 + strlen(display) + 1 + strlen(callback) + 1;
} else {
getSignalData(signal)[1 + strlen(display) + 1] = 0;
index = 1 + strlen(display) + 1 + 1;
}
getSignalData(signal)[index++] = setupSpec2;
getSignalData(signal)[index++] = setupSpec3;
getSignalData(signal)[index++] = alertConstruction.alertPattern;
getSignalData(signal)[index++] = alertConstruction.alertTone;
getSignalData(signal)[index++] = alertConstruction.alertTimeout;
getSignalData(signal)[index++] = displayTimeout;
memcpy(getSignalData(signal) + index, (UByte*) &dateAndTime.length, dateAndTime.length + 1);
memcpy(signal->Address, pmid, 3);
SendSignal(signal, APP_SS_PROCESS_ID, APP_SS_PRIMITIVE, SIO_MSF_SETUP_req);
return 1;
}
UByte voice_updateDisplay(PPIDType user, char * display)
{
SignalType *ccinfoSignal;
ApplicationInstanceType *applicationInstanceData;
PPID2PMID(&tmpPmid, user);
applicationInstanceData = getApplicationInstance(tmpPmid);
if (user != 0xffff && applicationInstanceData != NULL) {
NewSignal(sizeof(SignalType) + 14, (void**) &ccinfoSignal);
memcpy(ccinfoSignal->Address, tmpPmid, 3); /*pmid in address field*/
getSignalData(ccinfoSignal)[0] = 0x01; /*info element offset*/
getSignalData(ccinfoSignal)[1] = 0x28;
getSignalData(ccinfoSignal)[2] = 0x02 + strlen(display);
getSignalData(ccinfoSignal)[3] = 0x04;
getSignalData(ccinfoSignal)[4] = 0x0C;
memcpy(getSignalData(ccinfoSignal) + 5, display, strlen(display)); /*multidisplay, iwutoiwu, signal*/
SendSignal(ccinfoSignal, APP_CC_PROCESS_ID, APP_CC_PRIMITIVE, APPCCInfoReq);
return 1;
}
return 0;
}
void PPconnectionHandler(SignalType * Signal)
{
switch (Signal->Event)
{
case APPLICATION_PRIMITIVE:
{
switch (Signal->SubEvent)
{
case MSFInd:
{
AppMSFType* msfInd = (AppMSFType*) Signal;
char* msf = mem_malloc(msfInd->length + 1, 100);
memcpy(msf, getAppMSFTypeIE(msfInd), msfInd->length);
msf[msfInd->length] = '\0';
PrintStatus(0, msf);
if (strlen(msf) > 4) {
if (memcmp(msf, "DIAL", 4) == 0) {
char *number = &msf[4];
if (strlen(number) < 5) {
TimerType * timer = NewTimer(APPLICATION_PROCESS_ID_PP, WAIT_CONNECTION, 0);
StartTimer(timer, 200); /* wait 2 sec before dialing call*/
memcpy(numberToDial, number, strlen(number));
numberToDial[strlen(number)] = '\0';
}
}
}
mem_free(msf);
break;
}
}
}
break;
case IWU_PRIMITIVE:
{
switch (Signal->SubEvent)
{
case CC_SETUP_prim:
{
char* ptr;
char CallingPartyNo[INFO_BUFSIZE];
CcSetupPrimType *CcSetupPrim = (CcSetupPrimType *) Signal;
CallingPartyNoType *CallingPartyNoPtr;
SignalIEType *SignalIE;
TimerType * timer = NewTimer(APPLICATION_PROCESS_ID_PP, OFFHOOKTIMER, 0);
StartTimer(timer, 200); /* wait 2 sec before accepting call*/
CallingPartyNoPtr = (CallingPartyNoType *) FindInfoElement(CallingPartyNoId, getCcSetupPrimTypeIE(CcSetupPrim) - 2, CcSetupPrim-> SignalHeader. SignalLength - sizeof(CcSetupPrimType) + 2);
GetCallingPartyNo(CallingPartyNoPtr, CallingPartyNo, 32);
SignalIE = (SignalIEType *) FindInfoElement(SignalId, getCcSetupPrimTypeIE(CcSetupPrim) - 2, CcSetupPrim->SignalHeader. SignalLength - sizeof(CcSetupPrimType) + 2);
if (SignalIE) {
} else {
PrintStatus(0, "No SignalIE! EXTERNAL_RING");
}
Signal->SignalLength = sizeof(CcAlertingPrimType);
SendSignal(Signal, IWU_PROCESS_ID, IWU_PRIMITIVE, CC_ALERTING_prim);
ptr = StringPrint(StatusString, "CallingPartyNo [");
ptr = StringPrint(ptr, CallingPartyNo);
ptr = StringPrint(ptr, "]");
PrintStatus(0, StatusString);
connected = 1;
return;
}
case CC_RELEASE_COM_prim:
break;
case CC_RELEASE_prim:
{
SignalType* stopAudio;
Signal->SignalLength = sizeof(CcReleaseComPrimType);
SendSignal(Signal, IWU_PROCESS_ID, IWU_PRIMITIVE, CC_RELEASE_COM_prim);
NewSignal(sizeof(SignalType), (void**) &stopAudio);
SendSignal((SignalType*) stopAudio, DSP_PROCESS_ID, STOPAUDIO_EVENT, 0);
return;
}
case CC_CONNECT_ACK_prim:
{
EeReadDataReqType *EeReadDataReq;
NewSignal(sizeof(EeReadDataReqType) + sizeof(void *), (void **) &EeReadDataReq);
EeReadDataReq->ReturnTIPD = TIPD_APPLICATION;
EeReadDataReq->DataTypes = EEDT_ANYADDRESS;
/* getEeReadDataReqTypeDataPtr(EeReadDataReq)[0] = (void *) &eepromData; */
memset(&eepromData, 0x00, 1);
setAddressData(EEP_UserDataArea, 1);
SendSignal((SignalType *) EeReadDataReq, EE_PROCESS_ID, EE_PRIMITIVE, EE_READ_DATA_req);
setSignalHandler(APPLICATION_PROCESS_ID_PP, EEPROMWriteReadTestHandler, 0);
}
break;
case CC_CONNECT_prim:
{
if (firsttime) {
UByte * tmp;
/* UByte cnt;*/
/*MuteTransmitter();*/
/*for (cnt=0; cnt < 6; cnt++)*/
{
tmp = pp_get_speech_buffer(0);
if (tmp != 0) {
UByte count;
char* ptr;
ptr = StringPrint(StatusString, "***Buffer: [");
ptr = StrPrintHexAddr(ptr, (unsigned long) tmp);
for (count = 0; count < 40; count++) {
tmp[count] = 0x00;
}
tmp[0] = 0xCA;
tmp[1] = 0xFE;
tmp[2] = 0xBA;
tmp[3] = 0xBE;
tmp[4] = 0;
tmp[5] = 0;
tmp[6] = 0xff;
tmp[7] = 0xff;
ptr = StringPrint(ptr, "]");
PrintStatus(0, StatusString);
{
TimerType* connectionTimer = NewTimer(APPLICATION_PROCESS_ID_PP, PEIODICTIMER, 0);
StartTimer(connectionTimer, 500); /* Wait 1 sec*/
PrintStatus(0, "start the timer");
}
} else {
PrintStatus(0, "tmp==0");
}
}
firsttime = 0;
}
}
case CC_INFO_prim: /*do not break*/
break;
case CC_SETUP_ACK_prim:
break;
case CC_CALL_PROC_prim:
break;
case CC_ALERTING_prim:
break;
case SS_SETUP_prim:
handle_ss_setup(Signal);
break;
case SS_FACILITY_prim:
handle_ss_facility(Signal);
break;
default:
{
char* ptr;
ptr = StringPrint(StatusString, "Unknown IWU_PRIMITIVE [0x");
ptr = StrPrintHexByte(ptr, Signal->SubEvent);
ptr = StringPrint(ptr, "]");
PrintStatus(0, StatusString);
}
}
}
break;
case TIME_OUT_EVENT:
{
switch (Signal->SubEvent)
{
case SENDMSFTIMER:
{
/* PrintStatus(0, "Sending MSF");*/
/* SendMsfMessage("2001", "OK!");*/
}
break;
case WAIT_CONNECTION:
{
callUser_PP(numberToDial, 0);
setSignalHandler(APPLICATION_PROCESS_ID_PP, PPDialingHandler, 0);
}
break;
case OFFHOOKTIMER:
{
if (connected) {
PrintStatus(0, "Accepting call!");
off_hook();
}
}
break;
case PEIODICTIMER:
{
UByte * tmp;
TimerType* connectionTimer = NewTimer(APPLICATION_PROCESS_ID_PP, PEIODICTIMER, 0);
PrintStatus(0, "PEIODICTIMER");
StartTimer(connectionTimer, 500); /* Wait 1 sec*/
tmp = pp_get_speech_buffer(1);
if (tmp != 0) {
int c;
char* ptr;
ptr = StringPrint(StatusString, "***Buffer: [");
ptr = StrPrintHexAddr(ptr, (unsigned long) tmp);
ptr = StringPrint(ptr, "-");
for (c = 0; c < 8; c++) {
ptr = StrPrintHexByte(ptr, tmp[c]);
ptr = StringPrint(ptr, ",");
}
ptr = StringPrint(ptr, "]");
PrintStatus(0, StatusString);
} else {
PrintStatus(0, "tmp==0");
}
}
break;
default:
{
PrintStatus(0, "Unknown TIME_OUT_EVENT in connection handler");
}
}
}
break;
default:
{
PrintStatus(0, "Unknown event to connection handler");
}
}
DeleteBuffer(Signal);
}
void ApplicationSignalHandler_PP(SignalType * Signal)
{
switch (Signal->Event)
{
case IWU_PRIMITIVE:
{
switch (Signal->SubEvent)
{
case OM_SUBS_STATUS_ind:
{
OmSubsStatusIndType *OmSubsStatusInd = (OmSubsStatusIndType *) Signal;
if (OmSubsStatusInd->Status) {
OmSubsSelectReqType *OmSubsSelectReq;
NewBuffer(sizeof(OmSubsSelectReqType), (void **) &OmSubsSelectReq);
OmSubsSelectReq->SignalHeader.SignalLength = sizeof(OmSubsSelectReqType);
OmSubsSelectReq->SubsNo = 0;
InjectSignal((SignalType *) OmSubsSelectReq, IWU_PROCESS_ID, IWU_PRIMITIVE, OM_SUBS_SELECT_req, 0);
switch (OmSubsStatusInd->Status)
{
case SS_Locked:
{
setSignalHandler(APPLICATION_PROCESS_ID_PP, PPNotSubscribedHandler, 0);
}
break;
case SS_Locked | SS_Subscripted:
case SS_Subscripted:
{
setSignalHandler(APPLICATION_PROCESS_ID_PP, PPAlreadySubscribedHandler, 0);
}
break;
}
}
}
}
}
break;
case INITIALIZE_EVENT:
{
TimerType * timer = NewTimer(APPLICATION_PROCESS_ID_PP, WAIT_FOR_INIT, 0);
StartTimer(timer, 200);
}
break;
case TIME_OUT_EVENT:
{
switch (Signal->SubEvent)
{
case WAIT_FOR_INIT:
{
SignalType * ActivateSignal;
EeReadDataReqType *EeReadDataReq;
ProcessIdType ProcessId = IWU_PROCESS_ID;
EventType Event = ACTIVATE_EVENT;
SubEventType SubEvent = 0;
NewSignal(sizeof(SignalType), (void**) &ActivateSignal);
InjectSignal(ActivateSignal, ProcessId, Event, SubEvent, 0);
NewSignal(offsetof(EeReadDataReqType, DataTypes) + sizeof(U16Bits) + 2 * sizeof(void *), (void **) &EeReadDataReq);
EeReadDataReq->ReturnTIPD = PD_LCE;
EeReadDataReq->SubsNo = 0;
EeReadDataReq->DataTypes = EEDT_Ipei;
getEeReadDataReqTypeDataPtr(EeReadDataReq)[0] = (void *) &HandsetIPEI[0];
InjectSignal((SignalType *) EeReadDataReq, EE_PROCESS_ID, EE_PRIMITIVE, EE_READ_DATA_req, 0);
}
}
}
}
DeleteBuffer(Signal);
}
ParupaintNewDialog::ParupaintNewDialog(QWidget * parent) :
ParupaintDialog(parent, "new canvas..."), cwidth(0), cheight(0)
{
this->loadGeometry("newDialog");
this->setMinimumSize(300, 300);
QStringList dim_list = {
"120",
"500",
"540",
"800",
"1000",
"1280",
"1400",
"1600",
};
auto * preview = new ParupaintCanvasPreviewWidget;
// create width, height, middle buttons
width = new QComboBox;
width->setView(new QListView());
width->addItems(dim_list);
width->setEditable(true);
width->setCompleter(nullptr);
connect(width, &QComboBox::editTextChanged,
[=](const QString & str){
QSettings cfg;
cfg.setValue("canvas/lastwidth", str.toInt());
preview->setPreviewWidth(str.toInt());
});
height = new QComboBox;
height->setView(new QListView());
height->addItems(dim_list);
height->setEditable(true);
height->setCompleter(nullptr);
connect(height, &QComboBox::editTextChanged,
[=](const QString & str){
QSettings cfg;
cfg.setValue("canvas/lastheight", str.toInt());
preview->setPreviewHeight(str.toInt());
});
auto * flip_button = new QPushButton("flip");
flip_button->setToolTip("flip the values.");
connect(flip_button, &QPushButton::pressed, [=]{
auto hh = height->currentText();
height->setEditText(width->currentText());
width->setEditText(hh);
});
auto * cres_button = new QPushButton("take");
cres_button->setToolTip("take the current canvas dimensions.");
connect(cres_button, &QPushButton::pressed, [this]{
if(cwidth && cheight){
this->width->setEditText(QString::number(cwidth));
this->height->setEditText(QString::number(cheight));
}
});
flip_button->setMaximumHeight(25);
cres_button->setMaximumHeight(25);
flip_button->setMaximumWidth(40);
cres_button->setMaximumWidth(40);
auto * res_layout = new QHBoxLayout;
res_layout->setMargin(0);
res_layout->addWidget(width);
res_layout->addWidget(flip_button, Qt::AlignCenter);
res_layout->addWidget(cres_button, Qt::AlignCenter);
res_layout->addWidget(height);
// create buttons
auto * button_layout = new QHBoxLayout;
button_layout->setMargin(0);
auto * enter = new QPushButton("new");
enter->setDefault(true);
enter->setToolTip("create a new canvas with the given dimensions.");
connect(enter, &QPushButton::pressed, [=]{
int w = width->currentText().toInt();
if(w <= 0) return width->setFocus();
int h = height->currentText().toInt();
if(h <= 0) return height->setFocus();
emit NewSignal(w, h, false);
});
auto * resize = new QPushButton("resize");
resize->setToolTip("resize the current canvas with the given dimensions.");
connect(resize, &QPushButton::pressed, [=]{
int w = width->currentText().toInt();
if(w <= 0) return width->setFocus();
int h = height->currentText().toInt();
if(h <= 0) return height->setFocus();
emit NewSignal(w, h, true);
});
auto * reset = new QPushButton("reset");
reset->setToolTip("reset the current canvas, keeping its dimensions.");
connect(reset, &QPushButton::pressed, [=]{
if(!cwidth || !cheight) return;
emit NewSignal(cwidth, cheight, false);
});
connect(enter, &QPushButton::pressed, this, &ParupaintDialog::close);
connect(resize, &QPushButton::pressed, this, &ParupaintDialog::close);
connect(reset, &QPushButton::pressed, this, &ParupaintDialog::close);
button_layout->addWidget(enter);
button_layout->addWidget(resize);
button_layout->addWidget(reset);
QVBoxLayout * main_layout = new QVBoxLayout;
main_layout->addWidget(preview);
main_layout->addLayout(res_layout);
main_layout->addLayout(button_layout);
this->setLayout(main_layout);
this->setTabOrder(width, height);
QSettings cfg;
width->setEditText(cfg.value("canvas/lastwidth").toString());
height->setEditText(cfg.value("canvas/lastheight").toString());
this->setFocus();
}
