Merge branch 'clh' into liuyang
| | |
| | | void CAligner::initPins() |
| | | { |
| | | // å å
¥Pinåå§å代ç |
| | | LOGI("<CAligner>initPins"); |
| | | LOGD("<CAligner>initPins"); |
| | | addPin(SERVO::PinType::INPUT, _T("In1")); |
| | | addPin(SERVO::PinType::INPUT, _T("In2")); |
| | | addPin(SERVO::PinType::OUTPUT, _T("Out1")); |
| | |
| | | delete pStep; |
| | | } |
| | | } |
| | | |
| | | // VCR Event Report |
| | | // æºå¨ä¸æ¥æ«ç ç»æï¼æ«ç å¨é¢è®¡å®è£
å¨å·¡è¾¹æ£æºå¨ä¸ |
| | | { |
| | | CEqReadStep* pStep = new CEqReadStep(0x5fef, 15 * 2, |
| | | [&](void* pFrom, int code, const char* pszData, size_t size) -> int { |
| | | if (code == ROK && pszData != nullptr && size > 0) { |
| | | decodeVCREventReport((CStep*)pFrom, pszData, size); |
| | | } |
| | | return -1; |
| | | }); |
| | | pStep->setName(STEP_EQ_VCR1_EVENT_REPORT); |
| | | pStep->setProp("Port", (void*)1); |
| | | pStep->setWriteSignalDev(0x4a); |
| | | pStep->setReturnDev(0x91e); |
| | | if (addStep(STEP_ID_VCR1_EVENT_REPORT, pStep) != 0) { |
| | | delete pStep; |
| | | } |
| | | } |
| | | } |
| | | |
| | | void CAligner::onReceiveLBData(const char* pszData, size_t size) |
| | |
| | | void CBakeCooling::initPins() |
| | | { |
| | | // å å
¥Pinåå§å代ç |
| | | LOGI("<CBakeCooling>initPins"); |
| | | LOGD("<CBakeCooling>initPins"); |
| | | addPin(SERVO::PinType::INPUT, _T("In1")); |
| | | addPin(SERVO::PinType::INPUT, _T("In2")); |
| | | addPin(SERVO::PinType::OUTPUT, _T("Out")); |
| | |
| | | } |
| | | } |
| | | |
| | | // FAC Data Report |
| | | addFacDataReportStep(0x12589, 0x94d, 1); |
| | | /* |
| | | { |
| | | CEqReadStep* pStep = new CEqReadStep(0x12589, 133 * 2, |
| | | [&](void* pFrom, int code, const char* pszData, size_t size) -> int { |
| | | if (code == ROK && pszData != nullptr && size > 0) { |
| | | decodeFacDataReport((CStep*)pFrom, pszData, size); |
| | | } |
| | | return -1; |
| | | }); |
| | | pStep->setName(STEP_EQ_FAC_DATA_REPORT); |
| | | pStep->setProp("Port", (void*)1); |
| | | pStep->setWriteSignalDev(0x94d); |
| | | if (addStep(STEP_ID_FAC_DATA_REPORT, pStep) != 0) { |
| | | delete pStep; |
| | | } |
| | | } |
| | | */ |
| | | |
| | | // process start/end report |
| | | { |
| | | CEqReadStep* pStep = new CEqReadStep(0x11D3F, 13 * 2, |
| | |
| | | return (int)params.size(); |
| | | } |
| | | |
| | | int CBakeCooling::parsingProcessData(const char* pszData, size_t size, std::vector<CParam>& params) |
| | | { |
| | | return parsingParams(pszData, size, params); |
| | | } |
| | | |
| | | int CBakeCooling::parsingSVData(const char* pszData, size_t size, std::vector<CParam>& params) |
| | | { |
| | | /* |
| | | 1 Açç¤å·¥èºè¿è¡æ¥éª¤ 1Word 123456 |
| | | 2 Açç¤æ¸©æ§è¡¨1å½åå¼ 2Word 12345.6 |
| | | 3 Açç¤æ¸©æ§è¡¨2å½åå¼ 2Word 12345.6 |
| | | 4 Açç¤æ¸©æ§è¡¨4å½åå¼ 2Word 12345.6 |
| | | 5 Açç¤æ¸©æ§è¡¨5å½åå¼ 2Word 12345.6 |
| | | 6 Açç¤æ¸©æ§è¡¨6å½åå¼ 2Word 12345.6 |
| | | 7 Açç¤æ¸©æ§è¡¨7å½åå¼ 2Word 12345.6 |
| | | 8 Açç¤å©ä½æ¶é´ 1Word 1234.56 |
| | | 9 Aå·å´å·¥èºè¿è¡æ¥éª¤ 1Word 123456 |
| | | 10 Aè
å·å´å©ä½æ¶é´ 1Word 1234.56 |
| | | 11 Bçç¤å·¥èºè¿è¡æ¥éª¤ 1Word 123456 |
| | | 12 Bçç¤æ¸©æ§è¡¨1å½åå¼ 2Word 12345.6 |
| | | 13 Bçç¤æ¸©æ§è¡¨2å½åå¼ 2Word 12345.6 |
| | | 14 Bçç¤æ¸©æ§è¡¨4å½åå¼ 2Word 12345.6 |
| | | 15 Bçç¤æ¸©æ§è¡¨5å½åå¼ 2Word 12345.6 |
| | | 16 Bçç¤æ¸©æ§è¡¨6å½åå¼ 2Word 12345.6 |
| | | 17 Bçç¤æ¸©æ§è¡¨7å½åå¼ 2Word 12345.6 |
| | | 18 Bçç¤å©ä½æ¶é´ 1Word 1234.56 |
| | | 19 Bå·å´å·¥èºè¿è¡æ¥éª¤ 1Word 123456 |
| | | 20 Bè
å·å´å©ä½æ¶é´ 1Word 1234.56 |
| | | */ |
| | | |
| | | ASSERT(pszData); |
| | | if (size < 125) return 0; |
| | | int i = 0, v; |
| | | |
| | | |
| | | // 1.Açç¤å·¥èºè¿è¡æ¥éª¤ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8; |
| | | params.push_back(CParam("Açç¤å·¥èºè¿è¡æ¥éª¤", "", this->getName().c_str(), v)); |
| | | i += 2; |
| | | |
| | | // 2.Açç¤æ¸©æ§è¡¨1å½åå¼ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8 | (pszData[i + 2] & 0xff) << 16 | (pszData[i + 3] & 0xff) << 24; |
| | | params.push_back(CParam("Açç¤æ¸©æ§è¡¨1å½åå¼", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 4; |
| | | |
| | | // 3.Açç¤æ¸©æ§è¡¨2å½åå¼ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8 | (pszData[i + 2] & 0xff) << 16 | (pszData[i + 3] & 0xff) << 24; |
| | | params.push_back(CParam("Açç¤æ¸©æ§è¡¨2å½åå¼", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 4; |
| | | |
| | | // 4.Açç¤æ¸©æ§è¡¨4å½åå¼ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8 | (pszData[i + 2] & 0xff) << 16 | (pszData[i + 3] & 0xff) << 24; |
| | | params.push_back(CParam("Açç¤æ¸©æ§è¡¨4å½åå¼", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 4; |
| | | |
| | | // 5.Açç¤æ¸©æ§è¡¨5å½åå¼ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8 | (pszData[i + 2] & 0xff) << 16 | (pszData[i + 3] & 0xff) << 24; |
| | | params.push_back(CParam("Açç¤æ¸©æ§è¡¨5å½åå¼", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 4; |
| | | |
| | | // 6.Açç¤æ¸©æ§è¡¨6å½åå¼ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8 | (pszData[i + 2] & 0xff) << 16 | (pszData[i + 3] & 0xff) << 24; |
| | | params.push_back(CParam("Açç¤æ¸©æ§è¡¨6å½åå¼", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 4; |
| | | |
| | | // 7.Açç¤æ¸©æ§è¡¨7å½åå¼ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8 | (pszData[i + 2] & 0xff) << 16 | (pszData[i + 3] & 0xff) << 24; |
| | | params.push_back(CParam("Açç¤æ¸©æ§è¡¨7å½åå¼", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 4; |
| | | |
| | | // 8.Açç¤å©ä½æ¶é´ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8; |
| | | params.push_back(CParam("Açç¤å©ä½æ¶é´", "", this->getName().c_str(), v * 0.01f)); |
| | | i += 2; |
| | | |
| | | // 9.Aå·å´å·¥èºè¿è¡æ¥éª¤ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8; |
| | | params.push_back(CParam("Aå·å´å·¥èºè¿è¡æ¥éª¤", "", this->getName().c_str(), v)); |
| | | i += 2; |
| | | |
| | | // 10.Aè
å·å´å©ä½æ¶é´ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8; |
| | | params.push_back(CParam("Aè
å·å´å©ä½æ¶é´", "", this->getName().c_str(), v * 0.01f)); |
| | | i += 2; |
| | | |
| | | // 11.Bçç¤å·¥èºè¿è¡æ¥éª¤ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8; |
| | | params.push_back(CParam("Bçç¤å·¥èºè¿è¡æ¥éª¤", "", this->getName().c_str(), v)); |
| | | i += 2; |
| | | |
| | | // 12.Bçç¤æ¸©æ§è¡¨1å½åå¼ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8 | (pszData[i + 2] & 0xff) << 16 | (pszData[i + 3] & 0xff) << 24; |
| | | params.push_back(CParam("Bçç¤æ¸©æ§è¡¨1å½åå¼", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 4; |
| | | |
| | | // 13.Bçç¤æ¸©æ§è¡¨2å½åå¼ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8 | (pszData[i + 2] & 0xff) << 16 | (pszData[i + 3] & 0xff) << 24; |
| | | params.push_back(CParam("Bçç¤æ¸©æ§è¡¨2å½åå¼", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 4; |
| | | |
| | | // 14.Bçç¤æ¸©æ§è¡¨4å½åå¼ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8 | (pszData[i + 2] & 0xff) << 16 | (pszData[i + 3] & 0xff) << 24; |
| | | params.push_back(CParam("Bçç¤æ¸©æ§è¡¨4å½åå¼", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 4; |
| | | |
| | | // 15.Bçç¤æ¸©æ§è¡¨5å½åå¼ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8 | (pszData[i + 2] & 0xff) << 16 | (pszData[i + 3] & 0xff) << 24; |
| | | params.push_back(CParam("Bçç¤æ¸©æ§è¡¨5å½åå¼", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 4; |
| | | |
| | | // 16.Bçç¤æ¸©æ§è¡¨6å½åå¼ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8 | (pszData[i + 2] & 0xff) << 16 | (pszData[i + 3] & 0xff) << 24; |
| | | params.push_back(CParam("Bçç¤æ¸©æ§è¡¨6å½åå¼", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 4; |
| | | |
| | | // 17.Bçç¤æ¸©æ§è¡¨7å½åå¼ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8 | (pszData[i + 2] & 0xff) << 16 | (pszData[i + 3] & 0xff) << 24; |
| | | params.push_back(CParam("Bçç¤æ¸©æ§è¡¨7å½åå¼", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 4; |
| | | |
| | | // 18.Bçç¤å©ä½æ¶é´ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8; |
| | | params.push_back(CParam("Bçç¤å©ä½æ¶é´", "", this->getName().c_str(), v * 0.01f)); |
| | | i += 2; |
| | | |
| | | // 19.Bå·å´å·¥èºè¿è¡æ¥éª¤ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8; |
| | | params.push_back(CParam("Bå·å´å·¥èºè¿è¡æ¥éª¤", "", this->getName().c_str(), v)); |
| | | i += 2; |
| | | |
| | | // 20.Bè
å·å´å©ä½æ¶é´ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8; |
| | | params.push_back(CParam("Bè
å·å´å©ä½æ¶é´", "", this->getName().c_str(), v * 0.01f)); |
| | | i += 2; |
| | | |
| | | return (int)params.size(); |
| | | } |
| | | } |
| | |
| | | virtual short getSlotUnit(short slotNo) { return slotNo % 2 == 1 ? 0 : 1; }; |
| | | virtual bool isSlotProcessed(int slot); |
| | | virtual int parsingParams(const char* pszData, size_t size, std::vector<CParam>& parsms); |
| | | virtual int parsingProcessData(const char* pszData, size_t size, std::vector<CParam>& parsms); |
| | | virtual int parsingSVData(const char* pszData, size_t size, std::vector<CParam>& parsms); |
| | | }; |
| | | } |
| | | |
| | |
| | | } |
| | | } |
| | | |
| | | |
| | | { |
| | | CEqDateTimeSetCmdStep* pStep = new CEqDateTimeSetCmdStep(); |
| | | pStep->setName(STEP_DATETIME_SET_CMD); |
| | |
| | | } |
| | | } |
| | | } |
| | | |
| | | { |
| | | // Sent Out Job Report Downstream #1~9 |
| | | char szBuffer[256]; |
| | |
| | | } |
| | | } |
| | | |
| | | { |
| | | // FAC Data Report |
| | | CEqReadStep* pStep = new CEqReadStep(m_nIndex == 0 ? 0xA60E : 0xE60E, 108 * 2, |
| | | addFacDataReportStep(m_nIndex == 0 ? 0xA589 : 0xE589, |
| | | m_nIndex == 0 ? 0x34d : 0x64d, 1); |
| | | /* |
| | | { |
| | | CEqReadStep* pStep = new CEqReadStep(m_nIndex == 0 ? 0xA589 : 0xE589, 133 * 2, |
| | | [&](void* pFrom, int code, const char* pszData, size_t size) -> int { |
| | | if (code == ROK && pszData != nullptr && size > 0) { |
| | | decodeFacDataReport((CStep*)pFrom, pszData, size); |
| | |
| | | delete pStep; |
| | | } |
| | | } |
| | | */ |
| | | |
| | | // process start/end report |
| | | { |
| | |
| | | |
| | | return (int)params.size(); |
| | | } |
| | | |
| | | int CBonder::parsingProcessData(const char* pszData, size_t size, std::vector<CParam>& params) |
| | | { |
| | | return parsingParams(pszData, size, params); |
| | | } |
| | | |
| | | int CBonder::parsingSVData(const char* pszData, size_t size, std::vector<CParam>& params) |
| | | { |
| | | /* |
| | | 1 å·¥èºè¿è¡æ¥éª¤ 1Word 123456 |
| | | 2 æ°åååå½å 2Word 12345.6 |
| | | 3 ä¸è
ååå计 1Word 1234.56 |
| | | 4 管éç空è§å¼ FLOAT 123.456 |
| | | 5 è
ä½ç空è§å¼ FLOAT 123.456 |
| | | 6 ä¸è
温度1 1Word 12345.6 |
| | | 7 ä¸è
温度2 1Word 12345.6 |
| | | 8 ä¸è
温度3 1Word 12345.6 |
| | | 9 ä¸è
温度4 1Word 12345.6 |
| | | 10 ä¸è
温度5 1Word 12345.6 |
| | | 11 ä¸è
温度6 1Word 12345.6 |
| | | 12 ä¸è
温度1 1Word 12345.6 |
| | | 13 ä¸è
温度2 1Word 12345.6 |
| | | 14 ä¸è
温度3 1Word 12345.6 |
| | | 15 ä¸è
温度4 1Word 12345.6 |
| | | 16 ä¸è
温度5 1Word 12345.6 |
| | | 17 ä¸è
温度6 1Word 12345.6 |
| | | 18 ååå©ä½æ¶é´ 1Word 1234.56 |
| | | */ |
| | | |
| | | ASSERT(pszData); |
| | | if (size < 125) return 0; |
| | | int i = 0, v; |
| | | |
| | | |
| | | // 1.å·¥èºè¿è¡æ¥éª¤ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8; |
| | | params.push_back(CParam("å·¥èºè¿è¡æ¥éª¤", "", this->getName().c_str(), v)); |
| | | i += 2; |
| | | |
| | | // 2.æ°åååå½å |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8 | (pszData[i + 2] & 0xff) << 16 | (pszData[i + 3] & 0xff) << 24; |
| | | params.push_back(CParam("æ°åååå½å", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 4; |
| | | |
| | | // 3.ä¸è
ååå计 |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8; |
| | | params.push_back(CParam("ä¸è
ååå计", "", this->getName().c_str(), ((short)v) * 0.01f)); |
| | | i += 2; |
| | | |
| | | // 4.管éç空è§å¼ |
| | | params.push_back(CParam("管éç空è§å¼", "", this->getName().c_str(), (double)toFloat(&pszData[i]))); |
| | | i += 4; |
| | | |
| | | // 5.è
ä½ç空è§å¼ |
| | | params.push_back(CParam("è
ä½ç空è§å¼", "", this->getName().c_str(), (double)toFloat(&pszData[i]))); |
| | | i += 4; |
| | | |
| | | // 6.ä¸è
温度1 |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8; |
| | | params.push_back(CParam("ä¸è
温度1", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 2; |
| | | |
| | | // 7.ä¸è
温度2 |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8; |
| | | params.push_back(CParam("ä¸è
温度2", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 2; |
| | | |
| | | // 8.ä¸è
温度3 |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8; |
| | | params.push_back(CParam("ä¸è
温度3", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 2; |
| | | |
| | | // 9.ä¸è
温度4 |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8; |
| | | params.push_back(CParam("ä¸è
温度4", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 2; |
| | | |
| | | // 10.ä¸è
温度5 |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8; |
| | | params.push_back(CParam("ä¸è
温度5", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 2; |
| | | |
| | | // 11.ä¸è
温度6 |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8; |
| | | params.push_back(CParam("ä¸è
温度6", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 2; |
| | | |
| | | // 12.ä¸è
温度1 |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8; |
| | | params.push_back(CParam("ä¸è
温度1", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 2; |
| | | |
| | | // 13.ä¸è
温度2 |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8; |
| | | params.push_back(CParam("ä¸è
温度2", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 2; |
| | | |
| | | // 14.ä¸è
温度3 |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8; |
| | | params.push_back(CParam("ä¸è
温度3", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 2; |
| | | |
| | | // 15.ä¸è
温度4 |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8; |
| | | params.push_back(CParam("ä¸è
温度4", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 2; |
| | | |
| | | // 16.ä¸è
温度5 |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8; |
| | | params.push_back(CParam("ä¸è
温度5", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 2; |
| | | |
| | | // 17.ä¸è
温度6 |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8; |
| | | params.push_back(CParam("ä¸è
温度6", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 2; |
| | | |
| | | // 18.å çå©ä½æ¶é´ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8; |
| | | params.push_back(CParam("å çå©ä½æ¶é´", "", this->getName().c_str(), v * 0.01f)); |
| | | i += 2; |
| | | |
| | | // 19.ååå©ä½æ¶é´ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8; |
| | | params.push_back(CParam("ååå©ä½æ¶é´", "", this->getName().c_str(), v * 0.01f)); |
| | | i += 2; |
| | | |
| | | return (int)params.size(); |
| | | } |
| | | |
| | | } |
| | |
| | | virtual int onProcessStateChanged(PROCESS_STATE state); |
| | | virtual int getIndexerOperationModeBaseValue(); |
| | | virtual int parsingParams(const char* pszData, size_t size, std::vector<CParam>& parsms); |
| | | virtual int parsingProcessData(const char* pszData, size_t size, std::vector<CParam>& parsms); |
| | | virtual int parsingSVData(const char* pszData, size_t size, std::vector<CParam>& parsms); |
| | | |
| | | public: |
| | | void setIndex(unsigned int index); |
| | |
| | | LOGI("<CEquipment-%s>åéRobotCmdSæå.", m_strName.c_str()); |
| | | } |
| | | else { |
| | | LOGI("<CEquipment-%s>åéRobotCmds失败ï¼code:%d", m_strName.c_str(), code); |
| | | LOGE("<CEquipment-%s>åéRobotCmds失败ï¼code:%d", m_strName.c_str(), code); |
| | | } |
| | | |
| | | return 0; |
| | |
| | | void CEFEM::initPins() |
| | | { |
| | | // å å
¥Pinåå§å代ç |
| | | LOGI("<CEFEM>initPins"); |
| | | LOGD("<CEFEM>initPins"); |
| | | } |
| | | |
| | | void CEFEM::initSteps() |
| | |
| | | pStep->setName(STEP_EQ_CIM_MESSAGE_CONFIRM); |
| | | pStep->setWriteSignalDev(0x49); |
| | | if (addStep(STEP_ID_CIM_MSG_CONFIRM_REPORT, pStep) != 0) { |
| | | delete pStep; |
| | | } |
| | | } |
| | | |
| | | { |
| | | // VCR Event Report |
| | | // æºå¨ä¸æ¥æ«ç ç»æï¼æ«ç å¨é¢è®¡å®è£
å¨å·¡è¾¹æ£æºå¨ä¸ |
| | | CEqReadStep* pStep = new CEqReadStep(0x5fef, 15 * 2, |
| | | [&](void* pFrom, int code, const char* pszData, size_t size) -> int { |
| | | if (code == ROK && pszData != nullptr && size > 0) { |
| | | decodeVCREventReport((CStep*)pFrom, pszData, size); |
| | | } |
| | | return -1; |
| | | }); |
| | | pStep->setName(STEP_EQ_VCR1_EVENT_REPORT); |
| | | pStep->setProp("Port", (void*)1); |
| | | pStep->setWriteSignalDev(0x4a); |
| | | pStep->setReturnDev(0x91e); |
| | | if (addStep(STEP_ID_VCR1_EVENT_REPORT, pStep) != 0) { |
| | | delete pStep; |
| | | } |
| | | } |
| | |
| | | } |
| | | } |
| | | |
| | | { |
| | | // FAC Data Report |
| | | CEqReadStep* pStep = new CEqReadStep(0x6301, 108 * 2, |
| | | addFacDataReportStep(0x6589, 0x04d, 1); |
| | | /* |
| | | { |
| | | CEqReadStep* pStep = new CEqReadStep(0x6589, 133 * 2, |
| | | [&](void* pFrom, int code, const char* pszData, size_t size) -> int { |
| | | if (code == ROK && pszData != nullptr && size > 0) { |
| | | decodeFacDataReport((CStep*)pFrom, pszData, size); |
| | |
| | | delete pStep; |
| | | } |
| | | } |
| | | */ |
| | | |
| | | { |
| | | // JOB Data Request |
| | |
| | | |
| | | void CEFEM::printDebugRobotState() |
| | | { |
| | | LOGI("<CEFEM>Robot status:%d, ARM1:%s, ARM2:%s", |
| | | LOGD("<CEFEM>Robot status:%d, ARM1:%s, ARM2:%s", |
| | | m_robotData.status, |
| | | m_robotData.armState[0] ? _T("ON") : _T("OFF"), |
| | | m_robotData.armState[1] ? _T("ON") : _T("OFF")); |
| | |
| | | m_nAlarmCode = (unsigned int)CToolUnits::toInt16(&szBuffer[6]); |
| | | m_nAlarmLevel = (unsigned int)CToolUnits::toInt16(&szBuffer[8]); |
| | | |
| | | LOGI("<CEqAlarmStep> Equipment Alarm state Changed<State:%d, Unit:%d, Level:%d, Code:%d, ID:%d>", |
| | | LOGE("<CEqAlarmStep> Equipment Alarm state Changed<State:%d, Unit:%d, Level:%d, Code:%d, ID:%d>", |
| | | m_nAlarmState, m_nUnitId, m_nAlarmLevel, m_nAlarmCode, m_nAlarmId, |
| | | m_strText.c_str(), m_strDescription.c_str()); |
| | | |
| | |
| | | int CEqAlarmStep::onComplete() |
| | | { |
| | | CReadStep::onComplete(); |
| | | LOGI("<CEqAlarmStep> onComplete."); |
| | | LOGD("<CEqAlarmStep> onComplete."); |
| | | |
| | | return 0; |
| | | } |
| | |
| | | int CEqAlarmStep::onTimeout() |
| | | { |
| | | CReadStep::onTimeout(); |
| | | LOGI("<CEqAlarmStep> onTimeout."); |
| | | LOGE("<CEqAlarmStep> onTimeout."); |
| | | |
| | | return 0; |
| | | } |
| | |
| | | int CEqJobEventStep::onTimeout() |
| | | { |
| | | CReadStep::onTimeout(); |
| | | LOGI("<CEqJobEventStep> onTimeout."); |
| | | LOGE("<CEqJobEventStep> onTimeout."); |
| | | |
| | | return 0; |
| | | } |
| | |
| | | int CEqPortChangeStep::onTimeout() |
| | | { |
| | | CReadStep::onTimeout(); |
| | | LOGI("<CEQPortChangeStep> onTimeout."); |
| | | LOGE("<CEQPortChangeStep> onTimeout."); |
| | | |
| | | return 0; |
| | | } |
| | |
| | | int CEqProcessStep::onTimeout() |
| | | { |
| | | CReadStep::onTimeout(); |
| | | LOGI("<CEqProcessStep> onTimeout."); |
| | | LOGE("<CEqProcessStep> onTimeout."); |
| | | |
| | | return 0; |
| | | } |
| | |
| | | int CEqReadIntStep::onTimeout() |
| | | { |
| | | CReadStep::onTimeout(); |
| | | LOGI("<CEqReadIntStep> onTimeout."); |
| | | LOGE("<CEqReadIntStep> onTimeout."); |
| | | |
| | | return 0; |
| | | } |
| | |
| | | int nRet = m_pCclink->ReadData2(m_station, DeviceType::W, m_nDataDev, |
| | | (long)min(READ_BUFFER_MAX, m_nReadSize), szBuffer); |
| | | if (0 != nRet) { |
| | | LOGI("<CEqReadStep>Read data error."); |
| | | LOGE("<CEqReadStep>Read data error."); |
| | | if (m_onReadBlock != nullptr) { |
| | | m_onReadBlock(this, RERROR, nullptr, 0); |
| | | } |
| | | return -1; |
| | | } |
| | | |
| | | LOGI("<CEqReadStep>read data succeed."); |
| | | LOGD("<CEqReadStep>read data succeed."); |
| | | if (m_onReadBlock != nullptr) { |
| | | m_onReadBlock(this, ROK, szBuffer, m_nReadSize); |
| | | } |
| | |
| | | int CEqReadStep::onComplete() |
| | | { |
| | | CReadStep::onComplete(); |
| | | LOGI("<CEqReadStep> onComplete."); |
| | | LOGD("<CEqReadStep> onComplete."); |
| | | if (m_onReadBlock != nullptr) { |
| | | m_onReadBlock(this, RCOMPLETE, nullptr, 0); |
| | | } |
| | |
| | | int CEqReadStep::onTimeout() |
| | | { |
| | | CReadStep::onTimeout(); |
| | | LOGI("<CEqReadStep> onTimeout."); |
| | | LOGE("<CEqReadStep> onTimeout."); |
| | | if (m_onReadBlock != nullptr) { |
| | | m_onReadBlock(this, RTIMEOUT, nullptr, 0); |
| | | } |
| | |
| | | int CEqStatusStep::onTimeout() |
| | | { |
| | | CReadStep::onTimeout(); |
| | | LOGI("<CEqStatusStep> onTimeout."); |
| | | LOGE("<CEqStatusStep> onTimeout."); |
| | | |
| | | return 0; |
| | | } |
| | |
| | | int CEqVcrEventStep::onTimeout() |
| | | { |
| | | CReadStep::onTimeout(); |
| | | LOGI("<CEqVcrEventStep> onTimeout."); |
| | | LOGE("<CEqVcrEventStep> onTimeout."); |
| | | |
| | | return 0; |
| | | } |
| | |
| | | // process data report |
| | | CHECK_READ_STEP_SIGNAL(STEP_ID_PROCESS_DATA_REPORT, pszData, size); |
| | | |
| | | // FAC Data report |
| | | CHECK_READ_STEP_SIGNAL(STEP_ID_FAC_DATA_REPORT, pszData, size); |
| | | |
| | | // é
æ¹æ¹å |
| | | CHECK_READ_STEP_SIGNAL(STEP_ID_CURRENT_RECIPE_CHANGE_REPORT, pszData, size); |
| | | |
| | |
| | | CEquipment* pFromEq = pFromPin->getEquipment(); |
| | | ASSERT(pFromEq); |
| | | |
| | | LOGI("<CEquipment><%s-%s>æ¶å°æ¥èª<%s.%s>çIntent<%d,%s,0x%x>", |
| | | LOGD("<CEquipment><%s-%s>æ¶å°æ¥èª<%s.%s>çIntent<%d,%s,0x%x>", |
| | | this->getName().c_str(), |
| | | pPin->getName().c_str(), |
| | | pFromEq->getName().c_str(), |
| | |
| | | |
| | | ASSERT(pGlass); |
| | | Lock(); |
| | | pGlass->addPath(m_nID, getSlotUnit(putSlot)); |
| | | pGlass->addPath(m_nID, getSlotUnit(putSlot), putSlot); |
| | | CGlass* pBuddy = pGlass->getBuddy(); |
| | | if (pBuddy != nullptr) pBuddy->addPath(m_nID, getSlotUnit(putSlot), putSlot); |
| | | m_slot[putSlot - 1].setContext(pGlass); |
| | | pGlass->release(); // tempFetchOutéè¦è°ç¨ä¸æ¬¡release |
| | | Unlock(); |
| | |
| | | |
| | | |
| | | return nullptr; |
| | | } |
| | | |
| | | int CEquipment::getAllGlass(std::vector<CGlass*>& glasses) |
| | | { |
| | | Lock(); |
| | | for (int i = 0; i < SLOT_MAX; i++) { |
| | | if (!m_slot[i].isEnable()) continue; |
| | | CGlass* pGlass = (CGlass*)m_slot[i].getContext(); |
| | | if (pGlass != nullptr) { |
| | | pGlass->addRef(); |
| | | glasses.push_back(pGlass); |
| | | } |
| | | } |
| | | Unlock(); |
| | | |
| | | return (int)glasses.size(); |
| | | } |
| | | |
| | | CJobDataS* CEquipment::getJobDataSWithCassette(int cassetteSequenceNo, int jobSequenceNo) |
| | |
| | | LOGI("<CEquipment-%s>设置DispatchingModeæå.", m_strName.c_str()); |
| | | } |
| | | else { |
| | | LOGI("<CEquipment-%s>设置DispatchingMode失败ï¼code:%d", m_strName.c_str(), code); |
| | | LOGE("<CEquipment-%s>设置DispatchingMode失败ï¼code:%d", m_strName.c_str(), code); |
| | | } |
| | | |
| | | return 0; |
| | |
| | | LOGI("<CEquipment-%s>è¿åå¼: %d", m_strName.c_str(), retCode); |
| | | } |
| | | else { |
| | | LOGI("<CEquipment-%s>设置indexerOperationMode失败ï¼code:%d", m_strName.c_str(), code); |
| | | LOGE("<CEquipment-%s>设置indexerOperationMode失败ï¼code:%d", m_strName.c_str(), code); |
| | | } |
| | | |
| | | if (onWritedRetBlock != nullptr) { |
| | |
| | | } |
| | | else { |
| | | m_recipesManager.syncFailed(); |
| | | LOGI("<CEquipment-%s>请æ±åå
<%d>主é
æ¹å表失败ï¼code:%d", m_strName.c_str(), unitNo, code); |
| | | LOGE("<CEquipment-%s>请æ±åå
<%d>主é
æ¹å表失败ï¼code:%d", m_strName.c_str(), unitNo, code); |
| | | } |
| | | |
| | | return 0; |
| | |
| | | } |
| | | else { |
| | | m_recipesManager.syncFailed(); |
| | | LOGI("<CEquipment-%s>请æ±åå
<%d>主é
æ¹åæ°å表失败ï¼code:%d", m_strName.c_str(), unitNo, code); |
| | | LOGE("<CEquipment-%s>请æ±åå
<%d>主é
æ¹åæ°å表失败ï¼code:%d", m_strName.c_str(), unitNo, code); |
| | | } |
| | | |
| | | return 0; |
| | |
| | | CSlot* CEquipment::getProcessedSlot(MaterialsType putSlotType, BOOL bJobMode/* = FALSE*/) |
| | | { |
| | | for (int i = 0; i < SLOT_MAX; i++) { |
| | | if (m_nTestFlag == 1) LOGI("getProcessedSlot 001"); |
| | | if (m_nTestFlag == 1) LOGD("getProcessedSlot 001"); |
| | | if (!m_slot[i].isEnable()) continue; |
| | | if (m_nTestFlag == 1) LOGI("getProcessedSlot 002"); |
| | | if (m_nTestFlag == 1) LOGD("getProcessedSlot 002"); |
| | | if (m_slot[i].isLock()) continue; |
| | | if (m_nTestFlag == 1) LOGI("getProcessedSlot 003"); |
| | | if (m_nTestFlag == 1) LOGD("getProcessedSlot 003"); |
| | | CGlass* pGlass = (CGlass*)m_slot[i].getContext(); |
| | | if (!isSlotProcessed(i)) continue; |
| | | if (m_nTestFlag == 1) LOGI("getProcessedSlot 004"); |
| | | if (m_nTestFlag == 1) LOGD("getProcessedSlot 004"); |
| | | if (pGlass == nullptr) continue; |
| | | if (m_nTestFlag == 1) LOGI("getProcessedSlot 005"); |
| | | if (m_nTestFlag == 1) LOGD("getProcessedSlot 005"); |
| | | if (!pGlass->isScheduledForProcessing()) continue; |
| | | if (m_nTestFlag == 1) LOGI("getProcessedSlot 006"); |
| | | if (m_nTestFlag == 1) LOGD("getProcessedSlot 006"); |
| | | if (bJobMode && pGlass->getProcessJob() == nullptr) continue; |
| | | if (m_nTestFlag == 1) LOGI("getProcessedSlot 007"); |
| | | if (m_nTestFlag == 1) LOGD("getProcessedSlot 007"); |
| | | if(pGlass->getInspResult(m_nID, 0) == InspResult::Fail) continue; |
| | | int lsPath = m_slot[i].getLinkSignalPath(); |
| | | if(!m_bLinkSignalToUpstream[lsPath][SIGNAL_UPSTREAM_INLINE] |
| | | || m_bLinkSignalToUpstream[lsPath][SIGNAL_UPSTREAM_TROUBLE] |
| | | || !m_bLinkSignalToUpstream[lsPath][SIGNAL_INTERLOCK] |
| | | || !m_bLinkSignalToUpstream[lsPath][SIGNAL_SEND_ABLE] ) continue; |
| | | if (m_nTestFlag == 1) LOGI("getProcessedSlot 008"); |
| | | if (m_nTestFlag == 1) LOGD("getProcessedSlot 008"); |
| | | MaterialsType glassType = pGlass->getType(); |
| | | if (glassType == MaterialsType::G1 && putSlotType == MaterialsType::G2) continue; |
| | | if (m_nTestFlag == 1) LOGI("getProcessedSlot 009"); |
| | | if (m_nTestFlag == 1) LOGD("getProcessedSlot 009"); |
| | | if (glassType == MaterialsType::G2 && putSlotType == MaterialsType::G1) continue; |
| | | if (m_nTestFlag == 1) LOGI("getProcessedSlot 00a"); |
| | | if (m_nTestFlag == 1) LOGD("getProcessedSlot 00a"); |
| | | return &m_slot[i]; |
| | | } |
| | | |
| | |
| | | this->parsingParams((const char*)rawData.data(), rawData.size(), params); |
| | | pGlass->addParams(params); |
| | | |
| | | // å
³èçGlassä¹è¦æ´æ° |
| | | CGlass* pBuddy = pGlass->getBuddy(); |
| | | if (pBuddy != nullptr) { |
| | | pBuddy->addParams(params); |
| | | } |
| | | |
| | | return nRet; |
| | | } |
| | |
| | | vcrEventReport.getGlassId().c_str()); |
| | | |
| | | |
| | | // æ´æ°GlassçID |
| | | CGlass* pGlass = getGlassWithCassette(vcrEventReport.getCassetteSequenceNo(), |
| | | vcrEventReport.getJobSequenceNo()); |
| | | if (pGlass != nullptr) { |
| | | pGlass->setID(vcrEventReport.getGlassId().c_str()); |
| | | } |
| | | |
| | | |
| | | // ç¼åAttributeï¼ç¨äºè°è¯æ¶æ¾ç¤ºä¿¡æ¯ |
| | | unsigned int weight = 201; |
| | | CAttributeVector& attrubutes = pStep->attributeVector(); |
| | | vcrEventReport.getAttributeVector(attrubutes, weight); |
| | | |
| | | |
| | | // 0426, å
åºå®è¿å1(OK) |
| | | ((CReadStep*)pStep)->setReturnCode((short)VCR_Reply_Code::OK); |
| | | |
| | | |
| | | return 0; |
| | | } |
| | |
| | | |
| | | int CEquipment::decodeFacDataReport(CStep* pStep, const char* pszData, size_t size) |
| | | { |
| | | int index = 0; |
| | | std::string strSvTimeRecord, strSvData; |
| | | CToolUnits::convertString(&pszData[index], 8 * 2, strSvTimeRecord); |
| | | index += 128 * 2; |
| | | CToolUnits::convertString(&pszData[index], 100 * 2, strSvData); |
| | | index += 256 * 2; |
| | | CSVData svData; |
| | | int nRet = svData.unserialize(&pszData[0], (int)size); |
| | | if (nRet < 0) return nRet; |
| | | m_svDatas.push_back(svData); |
| | | |
| | | |
| | | // ç¼åAttributeï¼ç¨äºè°è¯æ¶æ¾ç¤ºä¿¡æ¯ |
| | | unsigned int weight = 201; |
| | | pStep->addAttribute(new CAttribute("SV Time Record", |
| | | strSvTimeRecord.c_str(), "", weight++)); |
| | | pStep->addAttribute(new CAttribute("SV Data", |
| | | strSvData.c_str(), "", weight++)); |
| | | |
| | | if (m_listener.onSVDataReport != nullptr) { |
| | | m_listener.onSVDataReport(this, &svData); |
| | | } |
| | | |
| | | return 0; |
| | | } |
| | |
| | | |
| | | |
| | | if (m_processState != PROCESS_STATE::Processing) { |
| | | Lock(); |
| | | m_svDatas.clear(); |
| | | Unlock(); |
| | | setProcessState(PROCESS_STATE::Processing); |
| | | } |
| | | |
| | |
| | | |
| | | return 0; |
| | | }; |
| | | |
| | | void CEquipment::addFacDataReportStep(int dataDev, int writeSignalDev, int port) |
| | | { |
| | | CEqReadStep* pStep = new CEqReadStep(dataDev, 133 * 2, |
| | | [&](void* pFrom, int code, const char* pszData, size_t size) -> int { |
| | | if (code == ROK && pszData != nullptr && size > 0) { |
| | | decodeFacDataReport((CStep*)pFrom, pszData, size); |
| | | } |
| | | return -1; |
| | | }); |
| | | pStep->setName(STEP_EQ_FAC_DATA_REPORT); |
| | | pStep->setProp("Port", (void*)port); |
| | | pStep->setWriteSignalDev(writeSignalDev); |
| | | if (addStep(STEP_ID_FAC_DATA_REPORT, pStep) != 0) { |
| | | delete pStep; |
| | | } |
| | | } |
| | | |
| | | std::vector<SERVO::CSVData>& CEquipment::getSVDatas() |
| | | { |
| | | return m_svDatas; |
| | | } |
| | | } |
| | |
| | | #include "CPortStatusReport.h" |
| | | #include "CSlot.h" |
| | | #include "CParam.h" |
| | | #include "CSVData.h" |
| | | |
| | | |
| | | namespace SERVO { |
| | |
| | | typedef std::function<void(void* pEiuipment, PROCESS_STATE state)> ONPROCESSSTATE; |
| | | typedef std::function<void(void* pEiuipment, short scanMap, short downMap)> ONMAPMISMATCH; |
| | | typedef std::function<void(void* pEiuipment, short status, __int64 data)> ONPORTSTATUSCHANGED; |
| | | |
| | | typedef struct _EquipmentListener |
| | | { |
| | | ONALIVE onAlive; |
| | |
| | | ONPROCESSSTATE onProcessStateChanged; |
| | | ONMAPMISMATCH onMapMismatch; |
| | | ONPORTSTATUSCHANGED onPortStatusChanged; |
| | | |
| | | ONVCREVENTREPORT onSVDataReport; |
| | | } EquipmentListener; |
| | | |
| | | |
| | |
| | | int setDispatchingMode(DISPATCHING_MODE mode, ONWRITED onWritedBlock = nullptr); |
| | | int indexerOperationModeChange(IDNEXER_OPERATION_MODE mode, ONWRITEDRET onWritedRetBlock); |
| | | void printDebugString001(); |
| | | |
| | | std::vector<SERVO::CSVData>& getSVDatas(); |
| | | |
| | | // 请æ±ä¸»é
æ¹å表 |
| | | // unitNo: 0:local; Others:unit No |
| | |
| | | // è§£æé
æ¹åæ°å表 |
| | | virtual int parsingParams(const char* pszData, size_t size, std::vector<CParam>& params) { return 0; }; |
| | | virtual int parsingParams(const char* pszData, size_t size, std::string& strOut); |
| | | virtual int parsingProcessData(const char* pszData, size_t size, std::vector<CParam>& params) { return 0; }; |
| | | virtual int parsingSVData(const char* pszData, size_t size, std::vector<CParam>& params) { return 0; }; |
| | | |
| | | // è·åæå®çSlot |
| | | CSlot* getSlot(int index); |
| | |
| | | CGlass* getGlassWithCassette(int cassetteSequenceNo, int jobSequenceNo); |
| | | CGlass* getAnyGlass(); |
| | | CGlass* getGlass(const char* pszGlassId); |
| | | int getAllGlass(std::vector<CGlass*>& glasses); |
| | | CJobDataS* getJobDataSWithCassette(int cassetteSequenceNo, int jobSequenceNo); |
| | | |
| | | // éªè¯ç»çåæ§½æ¯å¦å¹é
|
| | |
| | | float toFloat(const char* pszAddr); |
| | | |
| | | protected: |
| | | // é¨åä¼å/ç®å代ç ãæå®ç°é¨åï¼å°æ¶å¹³éºå¼ |
| | | void addFacDataReportStep(int dataDev, int writeSignalDev, int port); |
| | | |
| | | |
| | | protected: |
| | | BOOL m_bEnable; |
| | | EquipmentListener m_listener; |
| | | int m_nID; |
| | |
| | | CRecipesManager m_recipesManager; |
| | | CSlot m_slot[SLOT_MAX]; |
| | | PROCESS_STATE m_processState; |
| | | std::vector<SERVO::CSVData> m_svDatas; |
| | | |
| | | private: |
| | | CEquipment* m_pArm; |
| | |
| | | AfxMessageBox("设置EASæ¨¡å¼æåï¼"); |
| | | } |
| | | else { |
| | | LOGI("<CEquipment-%s>设置DispatchingMode失败ï¼code:%d", m_pEquipment->getName().c_str(), code); |
| | | LOGE("<CEquipment-%s>设置DispatchingMode失败ï¼code:%d", m_pEquipment->getName().c_str(), code); |
| | | AfxMessageBox("设置EAS模å¼å¤±è´¥ï¼"); |
| | | } |
| | | |
| | |
| | | if (CListCtrl::OnCreate(lpCreateStruct) == -1) |
| | | return -1; |
| | | |
| | | // æ¥è¡¨é£æ ¼åä¸¾ä¾ |
| | | SetExtendedStyle(GetExtendedStyle() |
| | | | LVS_EX_FULLROWSELECT | LVS_EX_HEADERDRAGDROP | LVS_EX_GRIDLINES | LVS_EX_DOUBLEBUFFER); |
| | | |
| | |
| | | |
| | | void CExpandableListCtrl::PreSubclassWindow() |
| | | { |
| | | // æ¥è¡¨é£æ ¼åä¸¾ä¾ |
| | | SetExtendedStyle(GetExtendedStyle() |
| | | | LVS_EX_FULLROWSELECT | LVS_EX_HEADERDRAGDROP | LVS_EX_GRIDLINES | LVS_EX_DOUBLEBUFFER); |
| | | |
| | | CListCtrl::PreSubclassWindow(); |
| | | } |
| | | |
| | | // ===== æ API ===== |
| | | CExpandableListCtrl::Node* CExpandableListCtrl::InsertRoot(const std::vector<CString>& cols) |
| | | { |
| | | auto n = std::make_unique<Node>((int)max(1, (int)cols.size())); |
| | |
| | | |
| | | void CExpandableListCtrl::RebuildVisible() |
| | | { |
| | | // 1) é建å¯è§åºå |
| | | m_visible.clear(); |
| | | for (auto& r : m_roots) appendVisible(r.get()); |
| | | |
| | | // 2) éç»/éå¡«æ°æ® |
| | | SetRedraw(FALSE); |
| | | DeleteAllItems(); |
| | | |
| | | // æå
¥å¯è§è¡ |
| | | for (int i = 0; i < (int)m_visible.size(); ++i) { |
| | | Node* n = m_visible[i]; |
| | | LVITEM lvi{}; |
| | |
| | | lvi.pszText = const_cast<LPTSTR>((LPCTSTR)(n->cols.empty() ? _T("") : n->cols[0])); |
| | | InsertItem(&lvi); |
| | | |
| | | for (int col = 1; col < GetHeaderCtrl()->GetItemCount(); ++col) { |
| | | const int colCount = GetHeaderCtrl() ? GetHeaderCtrl()->GetItemCount() : 1; |
| | | for (int col = 1; col < colCount; ++col) { |
| | | CString txt = (col < (int)n->cols.size()) ? n->cols[col] : _T(""); |
| | | SetItemText(i, col, txt); |
| | | } |
| | | } |
| | | |
| | | // é建åï¼æè¡å·é¢è²æ°ç»å¯¹é½ |
| | | m_rowColors.resize(GetItemCount()); |
| | | |
| | | SetRedraw(TRUE); |
| | | Invalidate(); |
| | | } |
| | |
| | | return m_visible[i]; |
| | | } |
| | | |
| | | // ===== é¢è² API ===== |
| | | void CExpandableListCtrl::SetNodeColor(Node* n, COLORREF text, COLORREF bk) |
| | | { |
| | | if (!n) return; |
| | | RowColor rc{}; |
| | | rc.text = text; rc.bk = bk; |
| | | rc.hasText = (text != CLR_DEFAULT); |
| | | rc.hasBk = (bk != CLR_DEFAULT); |
| | | m_colorByNode[n] = rc; |
| | | |
| | | for (int i = 0; i < (int)m_visible.size(); ++i) { |
| | | if (m_visible[i] == n) { |
| | | RedrawItems(i, i); |
| | | UpdateWindow(); |
| | | return; |
| | | } |
| | | } |
| | | } |
| | | |
| | | void CExpandableListCtrl::ClearNodeColor(Node* n) |
| | | { |
| | | if (!n) return; |
| | | auto it = m_colorByNode.find(n); |
| | | if (it != m_colorByNode.end()) { |
| | | m_colorByNode.erase(it); |
| | | for (int i = 0; i < (int)m_visible.size(); ++i) { |
| | | if (m_visible[i] == n) { |
| | | RedrawItems(i, i); |
| | | UpdateWindow(); |
| | | return; |
| | | } |
| | | } |
| | | } |
| | | } |
| | | |
| | | void CExpandableListCtrl::ClearAllColors() |
| | | { |
| | | m_colorByNode.clear(); |
| | | m_rowColors.clear(); |
| | | Invalidate(FALSE); |
| | | } |
| | | |
| | | // å
¼å®¹æ§æ¥å£ï¼æâå¯è§è¡å·âçè² |
| | | void CExpandableListCtrl::SetItemColor(DWORD_PTR iItem, COLORREF TextColor, COLORREF TextBkColor) |
| | | { |
| | | SetItemColorByVisibleIndex((int)iItem, TextColor, TextBkColor); |
| | | } |
| | | void CExpandableListCtrl::SetItemColorByVisibleIndex(int row, COLORREF text, COLORREF bk) |
| | | { |
| | | if (row < 0) return; |
| | | if (row >= (int)m_rowColors.size()) |
| | | m_rowColors.resize(row + 1); |
| | | |
| | | RowColor rc{}; |
| | | rc.text = text; rc.bk = bk; |
| | | rc.hasText = (text != CLR_DEFAULT); |
| | | rc.hasBk = (bk != CLR_DEFAULT); |
| | | m_rowColors[row] = rc; |
| | | |
| | | RedrawItems(row, row); |
| | | UpdateWindow(); |
| | | } |
| | | |
| | | CRect CExpandableListCtrl::expanderRectForRow(int row) const |
| | | { |
| | | CRect rcLabel; |
| | |
| | | |
| | | Node* n = const_cast<CExpandableListCtrl*>(this)->GetNodeByVisibleIndex(row); |
| | | if (!n || n->children.empty()) |
| | | return CRect(0, 0, 0, 0); // å¶åä¸å ä½ï¼ææ¬å°±ä¸ä¼è¢«å¤æ¨ä¸æ ¼ |
| | | return CRect(0, 0, 0, 0); |
| | | |
| | | const int indent = n->level; |
| | | const int left = rcLabel.left + m_expanderPadding + indent * 16; |
| | |
| | | ); |
| | | } |
| | | |
| | | // é¢è²è®¡ç®ï¼ä¼å
Node*ï¼å
¶æ¬¡è¡å·ï¼è¥éè¦å让系ç»é«äº®è¦ç |
| | | void CExpandableListCtrl::computeColorsForRow(int row, COLORREF& outText, COLORREF& outBk) const |
| | | { |
| | | outText = ListView_GetTextColor(const_cast<CExpandableListCtrl*>(this)->m_hWnd); |
| | | outBk = ListView_GetBkColor(const_cast<CExpandableListCtrl*>(this)->m_hWnd); |
| | | |
| | | const bool selected = (const_cast<CExpandableListCtrl*>(this)->GetItemState(row, LVIS_SELECTED) & LVIS_SELECTED) != 0; |
| | | const bool focusOnCtrl = (const_cast<CExpandableListCtrl*>(this)->GetSafeHwnd() == ::GetFocus()); |
| | | |
| | | if (m_preserveSelHighlight && selected) { |
| | | outBk = GetSysColor(focusOnCtrl ? COLOR_HIGHLIGHT : COLOR_3DFACE); |
| | | outText = GetSysColor(focusOnCtrl ? COLOR_HIGHLIGHTTEXT : COLOR_WINDOWTEXT); |
| | | return; |
| | | } |
| | | |
| | | // Node* é¢è² |
| | | if (Node* n = const_cast<CExpandableListCtrl*>(this)->GetNodeByVisibleIndex(row)) { |
| | | auto it = m_colorByNode.find(n); |
| | | if (it != m_colorByNode.end()) { |
| | | if (it->second.hasText) outText = it->second.text; |
| | | if (it->second.hasBk) outBk = it->second.bk; |
| | | return; |
| | | } |
| | | } |
| | | |
| | | // è¡å·é¢è² |
| | | if (row >= 0 && row < (int)m_rowColors.size()) { |
| | | const RowColor& rc = m_rowColors[row]; |
| | | if (rc.hasText) outText = rc.text; |
| | | if (rc.hasBk) outBk = rc.bk; |
| | | } |
| | | } |
| | | |
| | | void CExpandableListCtrl::OnClick(NMHDR* pNMHDR, LRESULT* pResult) |
| | | { |
| | | LPNMITEMACTIVATE pia = reinterpret_cast<LPNMITEMACTIVATE>(pNMHDR); |
| | | if (pia->iItem >= 0) { |
| | | CPoint pt = pia->ptAction; |
| | | |
| | | // å½ä¸å±å¼æé®ï¼ |
| | | CRect expRc = expanderRectForRow(pia->iItem); |
| | | if (expRc.PtInRect(pt)) { |
| | | Node* n = GetNodeByVisibleIndex(pia->iItem); |
| | |
| | | return; |
| | | |
| | | case CDDS_ITEMPREPAINT: |
| | | { |
| | | const int row = (int)pCD->nmcd.dwItemSpec; |
| | | COLORREF txt, bk; |
| | | computeColorsForRow(row, txt, bk); |
| | | pCD->clrText = txt; |
| | | pCD->clrTextBk = bk; |
| | | *pResult = CDRF_NOTIFYSUBITEMDRAW; |
| | | return; |
| | | } |
| | | |
| | | case CDDS_ITEMPREPAINT | CDDS_SUBITEM: |
| | | { |
| | |
| | | const int col = pCD->iSubItem; |
| | | CDC* pDC = CDC::FromHandle(pCD->nmcd.hdc); |
| | | |
| | | if (col == 0) |
| | | { |
| | | CRect rc; GetSubItemRect(row, 0, LVIR_LABEL, rc); |
| | | // å¦ææ²¡ææ èç¹ï¼çº¯å¹³å表ï¼ï¼é¦åä¹èµ°é»è®¤ç»å¶ |
| | | Node* n = GetNodeByVisibleIndex(row); |
| | | if (!n) { *pResult = CDRF_DODEFAULT; return; } |
| | | if (col != 0 || !n) { |
| | | *pResult = CDRF_DODEFAULT; |
| | | return; |
| | | } |
| | | |
| | | // 1) èæ¯/忝é¢è²ï¼ææ¯å¦éä¸ |
| | | const bool selected = (GetItemState(row, LVIS_SELECTED) & LVIS_SELECTED) != 0; |
| | | const bool focusOnCtrl = (GetSafeHwnd() == ::GetFocus()); |
| | | COLORREF bk = selected ? GetSysColor(focusOnCtrl ? COLOR_HIGHLIGHT : COLOR_3DFACE) |
| | | : ListView_GetBkColor(m_hWnd); |
| | | COLORREF txt = selected ? GetSysColor(focusOnCtrl ? COLOR_HIGHLIGHTTEXT : COLOR_WINDOWTEXT) |
| | | : ListView_GetTextColor(m_hWnd); |
| | | // é¦åèªç»ï¼æ 模å¼ï¼ |
| | | CRect rc; GetSubItemRect(row, 0, LVIR_LABEL, rc); |
| | | |
| | | // ä»
å¨éè¦æ¶å¡«å
èæ¯ï¼é¿å
âé»ä¸çâï¼ |
| | | COLORREF bk, txt; |
| | | computeColorsForRow(row, txt, bk); |
| | | |
| | | CBrush bkBrush(bk); |
| | | pDC->FillRect(rc, &bkBrush); |
| | | |
| | | // 2) å±å¼/æå æç¤ºï¼åèæ§é¡¹ç®çå³å¯¹é½åæ æ³ï¼ååç´ å¯¹é½ï¼çº¯GDIï¼ |
| | | if (!n->children.empty()) |
| | | { |
| | | CRect box = expanderRectForRow(row); |
| | | |
| | | // ---- å¯è°åæ°ï¼ä¸æ§ä»£ç å½åä¸è´ ---- |
| | | // å³ä¾§çç½ï¼ä¸ææ¬é´é/ç½æ ¼çº¿ä¿æè·ç¦»ï¼ |
| | | const int ROFFSET = 2; |
| | | // éå/å±å¼çâ宽度â设置ï¼å¥æ°æ´é¡ºç¼ï¼9/11 é½è¡ï¼ |
| | | const int WIDE = max(9, min(min(box.Width(), box.Height()), 13)); // â¶ çè¾¹é¿ |
| | | const int WIDE2 = WIDE / 2; // ä¸å |
| | | const int EXPANDED_WIDE = WIDE; // â¼ çè¾¹é¿ |
| | | const int WIDE = max(9, min(min(box.Width(), box.Height()), 13)); |
| | | const int WIDE2 = WIDE / 2; |
| | | const int EXPANDED_WIDE = WIDE; |
| | | |
| | | // 轻微å
缩ï¼é¿å
è´´è¾¹ï¼ä¸ä½ æ§ä»£ç âæé®è¦å·ä¸ä¸âåæï¼ |
| | | box.DeflateRect(1, 1); |
| | | |
| | | // ç»ä¸åå¶æ°å¯¹é½ï¼åå°ååç´ é¯é½¿ |
| | | auto even = [](int v) { return (v & 1) ? (v - 1) : v; }; |
| | | |
| | | // 计ç®âèªä¸åä¸âçåºååç§»ï¼ä¸æ§ TreeCtrl ä¸è´ |
| | | // è¿éç¨ box ä½ä¸º pRect |
| | | POINT pt[3]; |
| | | if (n->expanded) { |
| | | // â¼ |
| | | int nBottomOffset = (box.Height() - EXPANDED_WIDE) / 2; |
| | | pt[0].x = box.right - ROFFSET - EXPANDED_WIDE; |
| | | pt[0].y = box.bottom - nBottomOffset; |
| | |
| | | pt[2].y = box.bottom - nBottomOffset - EXPANDED_WIDE; |
| | | } |
| | | else { |
| | | // â¶ |
| | | int nBottomOffset = (box.Height() - WIDE) / 2; |
| | | |
| | | pt[0].x = box.right - ROFFSET - WIDE2; |
| | | pt[0].y = box.bottom - nBottomOffset - WIDE; |
| | | pt[1].x = box.right - ROFFSET - WIDE2; |
| | |
| | | pt[2].y = box.bottom - nBottomOffset - WIDE2; |
| | | } |
| | | |
| | | // ä»
å¡«å
ï¼ä¸æè¾¹ï¼æè¾¹ä¼å éå°é¶æï¼ï¼é¢è²ç¨ txt ä¸ä¸»é¢ä¸è´ |
| | | HGDIOBJ oldPen = pDC->SelectObject(GetStockObject(NULL_PEN)); |
| | | HBRUSH hBrush = CreateSolidBrush(txt); |
| | | HGDIOBJ oldBrush = pDC->SelectObject(hBrush); |
| | | |
| | | pDC->Polygon(pt, 3); |
| | | |
| | | pDC->SelectObject(oldPen); |
| | | pDC->SelectObject(oldBrush); |
| | | DeleteObject(hBrush); |
| | | } |
| | | |
| | | |
| | | |
| | | // 3) ææ¬ï¼åºäºé¦ååºåå³ç§»ï¼åºåæ¯å¦æåèç¹ï¼ |
| | | const int indentPx = n->level * 14; |
| | | const int baseLeft = rc.left + m_expanderPadding + indentPx; |
| | | |
| | | CRect textRc = rc; |
| | | if (!n->children.empty()) { |
| | | // æå项ï¼é¢çæé®ä½ + ææ¬é´é |
| | | textRc.left = baseLeft + m_expanderSize + m_textGap; |
| | | } |
| | | else { |
| | | // å¶åè¡ï¼ä¸é¢çæé®ä½ï¼åªç»ä¸ç¹ç¹å¶åé´éï¼è®©å±çº§ç¼©è¿ä»ç¶çæï¼ |
| | | constexpr int kLeafGap = 2; // ä½ å¯è° 0~4 |
| | | constexpr int kLeafGap = 2; |
| | | textRc.left = baseLeft + kLeafGap; |
| | | } |
| | | |
| | |
| | | CString txt0 = n->cols.empty() ? _T("") : n->cols[0]; |
| | | pDC->DrawText(txt0, textRc, DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_END_ELLIPSIS); |
| | | |
| | | |
| | | // ââ ç»å®ä¸è§ä¸ææ¬ä¹åï¼è¡¥ä¸æ¡è¯¥è¡çåºé¨æ¨ªåç½æ ¼çº¿ ââ |
| | | // ä»
å½å¼å¯äº LVS_EX_GRIDLINES æç»å¶ |
| | | if (GetExtendedStyle() & LVS_EX_GRIDLINES) |
| | | { |
| | | // ç¨æ´è¡ boundsï¼ä¿è¯æ¨ªçº¿è´¯ç©¿ææåçå¯è§å®½åº¦ |
| | | CRect rcRow; |
| | | GetSubItemRect(row, 0, LVIR_BOUNDS, rcRow); |
| | | |
| | | // åºè¾¹ y åæ ï¼ä¸ç³»ç»ç½æ ¼çº¿å¯¹é½ï¼ |
| | | CRect rcRow; GetSubItemRect(row, 0, LVIR_BOUNDS, rcRow); |
| | | const int y = rcRow.bottom - 1; |
| | | |
| | | // é¢è²ä¸ç³»ç»é£æ ¼æ¥è¿ï¼è¥è§å¾åæµ
ï¼å¯æ¢ COLOR_3DSHADOW |
| | | CPen pen(PS_SOLID, 1, GetSysColor(COLOR_3DLIGHT)); |
| | | CPen* oldPen = pDC->SelectObject(&pen); |
| | | |
| | | // 横线ä»è¡å·¦å°è¡å³ï¼å½åå¯è§åºåï¼ |
| | | pDC->MoveTo(rcRow.left, y); |
| | | pDC->LineTo(rcRow.right, y); |
| | | |
| | | pDC->SelectObject(oldPen); |
| | | } |
| | | |
| | | *pResult = CDRF_SKIPDEFAULT; |
| | | return; |
| | | } |
| | | |
| | | // å
¶ä»åé»è®¤ç»å¶ |
| | | *pResult = CDRF_DODEFAULT; |
| | | return; |
| | | } |
| | | |
| | | } |
| | | |
| | | *pResult = CDRF_DODEFAULT; |
| | | } |
| | | |
| | | // å
¼å®¹è¡ä¸ºï¼åæ¥ SetItemText å° Node->colsï¼ç»´æ¤è¡å·é¢è²æ°ç»çæå
¥/å é¤ |
| | | LRESULT CExpandableListCtrl::WindowProc(UINT message, WPARAM wParam, LPARAM lParam) |
| | | { |
| | | // 忥 SetItemText å° Nodeï¼A/W å
¼å®¹ï¼ |
| | | if (message == LVM_SETITEMTEXT |
| | | #ifdef LVM_SETITEMTEXTA |
| | | || message == LVM_SETITEMTEXTA |
| | | #endif |
| | | #ifdef LVM_SETITEMTEXTW |
| | | || message == LVM_SETITEMTEXTW |
| | | #endif |
| | | ) |
| | | { |
| | | int row = static_cast<int>(wParam); |
| | | LVITEM* p = reinterpret_cast<LVITEM*>(lParam); |
| | | if (p) { |
| | | Node* n = GetNodeByVisibleIndex(row); |
| | | if (n) { |
| | | int sub = p->iSubItem; |
| | | if (sub >= (int)n->cols.size()) |
| | | n->cols.resize(sub + 1); |
| | | CString newText = p->pszText ? p->pszText : _T(""); |
| | | n->cols[sub] = newText; |
| | | } |
| | | } |
| | | // ç»§ç»äº¤ç»åºç±»å¤ç |
| | | } |
| | | |
| | | LRESULT nRet = CListCtrl::WindowProc(message, wParam, lParam); |
| | | |
| | | // ç»´æ¤è¡å·é¢è²æ°ç»ï¼å
¼å®¹æ§ SetItemColorï¼ |
| | | if (message == LVM_INSERTITEM) { |
| | | if (nRet != -1) { |
| | | LVITEM* p = (LVITEM*)lParam; |
| | | int pos = p ? p->iItem : (int)nRet; |
| | | if (pos < 0) pos = (int)nRet; |
| | | if (pos > (int)m_rowColors.size()) pos = (int)m_rowColors.size(); |
| | | m_rowColors.insert(m_rowColors.begin() + pos, RowColor{}); // é»è®¤è² |
| | | } |
| | | } |
| | | else if (message == LVM_DELETEITEM) { |
| | | if (nRet != 0) { |
| | | int pos = (int)wParam; |
| | | if (pos >= 0 && pos < (int)m_rowColors.size()) |
| | | m_rowColors.erase(m_rowColors.begin() + pos); |
| | | } |
| | | } |
| | | else if (message == LVM_DELETEALLITEMS) { |
| | | if (nRet != 0) { |
| | | m_rowColors.clear(); |
| | | } |
| | | } |
| | | |
| | | return nRet; |
| | | } |
| | | |
| | | // CExpandableListCtrl.cpp é |
| | | void CExpandableListCtrl::ClearTree() |
| | | { |
| | | // æ¸
æ°æ® |
| | | m_roots.clear(); |
| | | m_visible.clear(); |
| | | |
| | | // æ¸
å¯è§é¡¹ï¼å¡å¿
ï¼å¦åæ§é¡µçè¡ä¼æ®çï¼ |
| | | SetRedraw(FALSE); |
| | | DeleteAllItems(); |
| | | SetRedraw(TRUE); |
| | | |
| | | Invalidate(); |
| | | } |
| | | |
| | | |
| | |
| | | #pragma once |
| | | #include <vector> |
| | | #include <memory> |
| | | #include <unordered_map> |
| | | |
| | | class CExpandableListCtrl : public CListCtrl |
| | | { |
| | |
| | | std::vector<CString> cols; // ååææ¬ |
| | | bool expanded = false; |
| | | int level = 0; // 缩è¿å±çº§ |
| | | |
| | | Node(int nCols = 1) : cols(nCols) {} |
| | | }; |
| | | |
| | | CExpandableListCtrl(); |
| | | virtual ~CExpandableListCtrl(); |
| | | |
| | | // æ°æ®æå»º |
| | | // ===== æ æ°æ®æå»ºï¼éè¦æå åè½æ¶ä½¿ç¨ï¼çº¯å¹³å表å¯å¿½ç¥ï¼ ===== |
| | | Node* InsertRoot(const std::vector<CString>& cols); |
| | | Node* InsertChild(Node* parent, const std::vector<CString>& cols); |
| | | |
| | | // å±å¼/æå |
| | | void Expand(Node* n); |
| | | void Collapse(Node* n); |
| | | void Toggle(Node* n); |
| | | |
| | | // å·æ°å¯è§å表 |
| | | void RebuildVisible(); |
| | | |
| | | // 便æ·ï¼éè¿å¯è§è¡å·å Node* |
| | | Node* GetNodeByVisibleIndex(int i) const; |
| | | |
| | | // ===== è¡é
è² API ===== |
| | | // A) æ Node* çè²ï¼ç¨äºæ /坿å åºæ¯ï¼ç´¢å¼ååä¸åå½±åï¼ |
| | | void SetNodeColor(Node* n, COLORREF text, COLORREF bk); |
| | | void ClearNodeColor(Node* n); |
| | | void ClearAllColors(); |
| | | |
| | | // B) å
¼å®¹æ§æ¥å£ï¼æâå¯è§è¡å·âçè²ï¼ä¸ä½ å½å页é¢ä»£ç ä¸è´ï¼ |
| | | void SetItemColor(DWORD_PTR iItem, COLORREF TextColor, COLORREF TextBkColor); // å
¼å®¹ ListCtrlEx |
| | | void SetItemColorByVisibleIndex(int row, COLORREF text, COLORREF bk); // åä¸å«å |
| | | |
| | | // éä¸è¡æ¯å¦ä½¿ç¨ç³»ç»é«äº®ï¼TRUEï¼é»è®¤ï¼ï¼ |
| | | // è¥ä¸º FALSEï¼åé䏿¶ä»æ¾ç¤ºèªå®ä¹é¢è² |
| | | void SetPreserveSelectionHighlight(BOOL b) { m_preserveSelHighlight = b; } |
| | | |
| | | // æ¸
餿 |
| | | void ClearTree(); |
| | | |
| | | protected: |
| | | virtual void PreSubclassWindow(); |
| | | afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct); |
| | | afx_msg void OnClick(NMHDR* pNMHDR, LRESULT* pResult); |
| | | afx_msg void OnCustomDraw(NMHDR* pNMHDR, LRESULT* pResult); |
| | | virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam) override; |
| | | DECLARE_MESSAGE_MAP() |
| | | |
| | | private: |
| | | void appendVisible(Node* n); |
| | | CRect expanderRectForRow(int row) const; // é¦åå±å¼æé®åºå |
| | | virtual void PreSubclassWindow(); |
| | | |
| | | protected: |
| | | // æ¶æ¯ |
| | | afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct); |
| | | afx_msg void OnClick(NMHDR* pNMHDR, LRESULT* pResult); |
| | | afx_msg void OnCustomDraw(NMHDR* pNMHDR, LRESULT* pResult); |
| | | DECLARE_MESSAGE_MAP() |
| | | void computeColorsForRow(int row, COLORREF& outText, COLORREF& outBk) const; |
| | | |
| | | private: |
| | | std::vector<std::unique_ptr<Node>> m_roots; // é¡¶å±èç¹ |
| | |
| | | int m_expanderPadding = 6; // é¦åå
ä¾§è¾¹è· |
| | | int m_expanderSize = 10; // å°ä¸è§/æ¹åå¤§å° |
| | | int m_textGap = 6; |
| | | |
| | | struct RowColor { |
| | | COLORREF text = CLR_DEFAULT; |
| | | COLORREF bk = CLR_DEFAULT; |
| | | bool hasText = false; |
| | | bool hasBk = false; |
| | | }; |
| | | |
| | | // é¢è²ï¼ä¸¤è·¯æ¥æºï¼ä¼å
级ï¼Node* > è¡å·ï¼ |
| | | std::unordered_map<Node*, RowColor> m_colorByNode; // æ èç¹é¢è² |
| | | std::vector<RowColor> m_rowColors; // æå½åå¯è§è¡å·çé¢è²ï¼å
¼å®¹æ§ä»£ç ï¼ |
| | | |
| | | BOOL m_preserveSelHighlight = TRUE; // TRUE=é䏿¶ä¼å
ç³»ç»é«äº® |
| | | }; |
| | |
| | | void CFliper::initPins() |
| | | { |
| | | // å å
¥Pinåå§å代ç |
| | | LOGI("<CFliper>initPins"); |
| | | LOGD("<CFliper>initPins"); |
| | | addPin(SERVO::PinType::INPUT, _T("In")); |
| | | addPin(SERVO::PinType::OUTPUT, _T("Out1")); |
| | | addPin(SERVO::PinType::OUTPUT, _T("Out2")); |
| | |
| | | |
| | | if (m_pBuddy != nullptr) { |
| | | m_pBuddy->release(); |
| | | m_pBuddy = nullptr; |
| | | } |
| | | } |
| | | |
| | |
| | | return strText; |
| | | } |
| | | |
| | | MaterialsType CGlass::getType() |
| | | MaterialsType CGlass::getType() const |
| | | { |
| | | return m_type; |
| | | } |
| | |
| | | m_strID = pszID; |
| | | } |
| | | |
| | | std::string& CGlass::getID() |
| | | const std::string& CGlass::getID() const |
| | | { |
| | | return m_strID; |
| | | } |
| | |
| | | return m_pPath; |
| | | } |
| | | |
| | | CPath* CGlass::getPathWithEq(unsigned int nEqId, unsigned int nUnit) |
| | | std::string CGlass::getPathDescription() const |
| | | { |
| | | std::string strOut, strPath; |
| | | char szBuffer[256]; |
| | | |
| | | CPath* pTemp = m_pPath; |
| | | while (pTemp != nullptr) { |
| | | pTemp->getSimpleDescription(strPath); |
| | | if (strPath.compare("ARM1") != 0 && strPath.compare("ARM2") != 0) { |
| | | if (!strOut.empty()) strOut.append(" -> "); |
| | | strOut.append(strPath); |
| | | } |
| | | |
| | | pTemp = pTemp->getNext(); |
| | | } |
| | | |
| | | return strOut; |
| | | } |
| | | |
| | | CPath* CGlass::getPathWithEq(unsigned int nEqId, unsigned int nUnit) const |
| | | { |
| | | CPath* pTemp = m_pPath; |
| | | while (pTemp != nullptr) { |
| | |
| | | return nullptr; |
| | | } |
| | | |
| | | void CGlass::addPath(unsigned int nEqId, unsigned int nUnit) |
| | | void CGlass::addPath(unsigned int nEqId, unsigned int nUnit, unsigned int slot) |
| | | { |
| | | CPath* pPath = new CPath(nEqId, nUnit); |
| | | CPath* pPath = new CPath(nEqId, nUnit, slot); |
| | | if (m_pPath == nullptr) { |
| | | m_pPath = pPath; |
| | | } |
| | |
| | | return m_pBuddy; |
| | | } |
| | | |
| | | std::string& CGlass::getBuddyId() |
| | | const std::string& CGlass::getBuddyId() const |
| | | { |
| | | return m_strBuddyId; |
| | | } |
| | | |
| | | void CGlass::setBuddyId(std::string& strId) |
| | | { |
| | | m_strBuddyId = strId; |
| | | } |
| | | |
| | | int CGlass::processEnd(unsigned int nEqId, unsigned int nUnit) |
| | |
| | | return 0; |
| | | } |
| | | |
| | | InspResult CGlass::getInspResult(unsigned int nEqId, unsigned int nUnit) |
| | | InspResult CGlass::getInspResult(unsigned int nEqId, unsigned int nUnit) const |
| | | { |
| | | CPath* pPath = getPathWithEq(nEqId, nUnit); |
| | | if (pPath == nullptr) return InspResult::NotInspected; |
| | | |
| | | return pPath->getInspResult(); |
| | | } |
| | | |
| | | InspResult CGlass::getAOIInspResult() const |
| | | { |
| | | return getInspResult(EQ_ID_MEASUREMENT, 0); |
| | | } |
| | | |
| | | std::string CGlass::getStateText() |
| | |
| | | |
| | | void CGlass::markStart() |
| | | { |
| | | m_state = GlsState::InProcess; |
| | | m_tStart = std::chrono::system_clock::now(); |
| | | } |
| | | |
| | | void CGlass::markEnd() |
| | | { |
| | | m_state = GlsState::Completed; |
| | | m_tEnd = std::chrono::system_clock::now(); |
| | | } |
| | | |
| | |
| | | { |
| | | return m_params; |
| | | } |
| | | |
| | | std::string CGlass::getParamsDescription() const |
| | | { |
| | | std::string strOut; |
| | | |
| | | char szBuffer[256]; |
| | | for (auto p : m_params) { |
| | | if (!strOut.empty()) strOut.append(","); |
| | | if (p.getValueType() == PVT_INT) { |
| | | sprintf_s(szBuffer, 256, "%s:%d", p.getName().c_str(), p.getIntValue()); |
| | | } |
| | | else if (p.getValueType() == PVT_DOUBLE) { |
| | | sprintf_s(szBuffer, 256, "%s:%f", p.getName().c_str(), p.getDoubleValue()); |
| | | } |
| | | strOut.append(szBuffer); |
| | | } |
| | | |
| | | return strOut; |
| | | } |
| | | } |
| | |
| | | public: |
| | | virtual std::string& getClassName(); |
| | | virtual std::string toString(); |
| | | short getCassetteSequenceNo() { return m_jobDataS.getCassetteSequenceNo(); } |
| | | short getJobSequenceNo() { return m_jobDataS.getJobSequenceNo(); } |
| | | MaterialsType getType(); |
| | | short getCassetteSequenceNo() const { return m_jobDataS.getCassetteSequenceNo(); } |
| | | short getJobSequenceNo() const { return m_jobDataS.getJobSequenceNo(); } |
| | | MaterialsType getType() const; |
| | | void setType(MaterialsType type); |
| | | void setID(const char* pszID); |
| | | std::string& getID(); |
| | | const std::string& getID() const; |
| | | void setOriginPort(int port, int slot); |
| | | void getOrginPort(int& port, int& slot); |
| | | BOOL isScheduledForProcessing(); |
| | | void setScheduledForProcessing(BOOL bProcessing); |
| | | CProcessJob* getProcessJob(); |
| | | void setProcessJob(CProcessJob* pProcessJob); |
| | | CPath* getPathWithEq(unsigned int nEqId, unsigned int nUnit); |
| | | CPath* getPathWithEq(unsigned int nEqId, unsigned int nUnit) const; |
| | | CPath* getPath(); |
| | | void addPath(unsigned int nEqId, unsigned int nUnit); |
| | | void addPath(unsigned int nEqId, unsigned int nUnit, unsigned int slot); |
| | | std::string getPathDescription() const; |
| | | std::string getParamsDescription() const; |
| | | void serialize(CArchive& ar); |
| | | void setJobDataS(CJobDataS* pJobDataS); |
| | | void updateJobDataS(CJobDataS* pJobDataS); |
| | |
| | | BOOL setBuddy(CGlass* pGlass); |
| | | BOOL forceSetBuddy(CGlass* pGlass); |
| | | CGlass* getBuddy(); |
| | | std::string& getBuddyId(); |
| | | const std::string& getBuddyId() const; |
| | | void setBuddyId(std::string& strId); |
| | | int processEnd(unsigned int nEqId, unsigned int nUnit); |
| | | BOOL isProcessed(unsigned int nEqId, unsigned int nUnit); |
| | | int setInspResult(unsigned int nEqId, unsigned int nUnit, InspResult result); |
| | | InspResult getInspResult(unsigned int nEqId, unsigned int nUnit); |
| | | InspResult getInspResult(unsigned int nEqId, unsigned int nUnit) const; |
| | | InspResult getAOIInspResult() const; |
| | | |
| | | public: |
| | | // æ°å¢ç¶æ |
| | |
| | | m_pOwner = pOwner; |
| | | } |
| | | |
| | | int CJobDataS::getCassetteSequenceNo() |
| | | int CJobDataS::getCassetteSequenceNo() const |
| | | { |
| | | return m_nCassetteSequenceNo; |
| | | } |
| | |
| | | m_nCassetteSequenceNo = no; |
| | | } |
| | | |
| | | int CJobDataS::getJobSequenceNo() |
| | | int CJobDataS::getJobSequenceNo() const |
| | | { |
| | | return m_nJobSequenceNo; |
| | | } |
| | |
| | | void copy(CJobDataS* pScr); |
| | | void update(CJobDataS* pScr); |
| | | CJobDataB& getJobDataB(CJobDataB& jobDataB); |
| | | int getCassetteSequenceNo(); |
| | | int getCassetteSequenceNo() const; |
| | | void setCassetteSequenceNo(int no); |
| | | int getJobSequenceNo(); |
| | | int getJobSequenceNo() const; |
| | | void setJobSequenceNo(int no); |
| | | std::string& getLotId(); |
| | | void setLotId(const char* pszId); |
| | |
| | | void CLoadPort::initPins() |
| | | { |
| | | // å å
¥Pinåå§å代ç |
| | | LOGI("<CLoadPort>initPins"); |
| | | LOGD("<CLoadPort>initPins"); |
| | | addPin(SERVO::PinType::INPUT, _T("In")); |
| | | addPin(SERVO::PinType::OUTPUT, _T("Out")); |
| | | } |
| | |
| | | LOGI("<CLoadPort-%d>设置Port typeæå.", m_nIndex); |
| | | } |
| | | else { |
| | | LOGI("<CLoadPort-%d>设置Port type失败ï¼code:%d", m_nIndex, code); |
| | | LOGE("<CLoadPort-%d>设置Port type失败ï¼code:%d", m_nIndex, code); |
| | | } |
| | | if (onWritedBlock != nullptr) { |
| | | return onWritedBlock(code); |
| | |
| | | LOGI("<CLoadPort-%d>%s Portæå.", m_nIndex, bEnable ? _T("å¯ç¨") : _T("ç¦ç¨")); |
| | | } |
| | | else { |
| | | LOGI("<CLoadPort-%d>%s Port失败ï¼code:%d", m_nIndex, bEnable ? _T("å¯ç¨") : _T("ç¦ç¨"), code); |
| | | LOGE("<CLoadPort-%d>%s Port失败ï¼code:%d", m_nIndex, bEnable ? _T("å¯ç¨") : _T("ç¦ç¨"), code); |
| | | } |
| | | if (onWritedBlock != nullptr) { |
| | | return onWritedBlock(code); |
| | |
| | | LOGI("<CLoadPort-%d>设置Port modeæå.", m_nIndex); |
| | | } |
| | | else { |
| | | LOGI("<CLoadPort-%d>设置Port mode失败ï¼code:%d", m_nIndex, code); |
| | | LOGE("<CLoadPort-%d>设置Port mode失败ï¼code:%d", m_nIndex, code); |
| | | } |
| | | if (onWritedBlock != nullptr) { |
| | | return onWritedBlock(code); |
| | |
| | | LOGI("<CLoadPort-%d>设置Cassette Typeæå.", m_nIndex); |
| | | } |
| | | else { |
| | | LOGI("<CLoadPort-%d>设置Cassette Type失败ï¼code:%d", m_nIndex, code); |
| | | LOGE("<CLoadPort-%d>设置Cassette Type失败ï¼code:%d", m_nIndex, code); |
| | | } |
| | | if (onWritedBlock != nullptr) { |
| | | return onWritedBlock(code); |
| | |
| | | LOGI("<CLoadPort-%d>设置Transfer modeæå.", m_nIndex + 1); |
| | | } |
| | | else { |
| | | LOGI("<CLoadPort-%d>设置Transfer mode失败ï¼code:%d", m_nIndex + 1, code); |
| | | LOGE("<CLoadPort-%d>设置Transfer mode失败ï¼code:%d", m_nIndex + 1, code); |
| | | } |
| | | if (onWritedBlock != nullptr) { |
| | | return onWritedBlock(code); |
| | |
| | | LOGI("<CLoadPort-%d>%s Auto Changeæå.", m_nIndex, bEnable ? _T("å¯ç¨") : _T("ç¦ç¨")); |
| | | } |
| | | else { |
| | | LOGI("<CLoadPort-%d>%s Auto Change失败ï¼code:%d", m_nIndex, bEnable ? _T("å¯ç¨") : _T("ç¦ç¨"), code); |
| | | LOGE("<CLoadPort-%d>%s Auto Change失败ï¼code:%d", m_nIndex, bEnable ? _T("å¯ç¨") : _T("ç¦ç¨"), code); |
| | | } |
| | | if (onWritedBlock != nullptr) { |
| | | return onWritedBlock(code); |
| | |
| | | |
| | | CGlass* pGlass = theApp.m_model.m_glassPool.allocaGlass(); |
| | | pGlass->setOriginPort(m_nIndex, i); |
| | | pGlass->addPath(m_nID, 0); |
| | | pGlass->addPath(m_nID, 0, i + 1); |
| | | pGlass->processEnd(m_nID, 0); |
| | | pGlass->setID(szBuffer); |
| | | pGlass->setType(type); |
| | |
| | | CGlass* pGlass = theApp.m_model.m_glassPool.allocaGlass(); |
| | | pGlass->setOriginPort(m_nIndex, i); |
| | | pGlass->setScheduledForProcessing(i % 2 == 1); |
| | | pGlass->addPath(m_nID, 0); |
| | | pGlass->addPath(m_nID, 0, i + 1); |
| | | pGlass->processEnd(m_nID, 0); |
| | | pGlass->setID(szBuffer); |
| | | pGlass->setType(m_cassetteType); |
| | |
| | | |
| | | CGlass* pGlass = theApp.m_model.m_glassPool.allocaGlass(); |
| | | pGlass->setOriginPort(m_nIndex, nSlotIndex); |
| | | pGlass->addPath(m_nID, 0); |
| | | pGlass->addPath(m_nID, 0, slot.nSlotID); |
| | | pGlass->processEnd(m_nID, 0); |
| | | pGlass->setID(szBuffer); |
| | | pGlass->setType(static_cast<SERVO::MaterialsType>(config.nMaterialType)); |
| | |
| | | BoardVersion version{}; |
| | | int nRet = m_cclink.GetBoardVersion(version); |
| | | if (nRet == 0) { |
| | | LOGI("çæ¬ä¿¡æ¯ï¼%s.", version.toString().c_str()); |
| | | LOGD("çæ¬ä¿¡æ¯ï¼%s.", version.toString().c_str()); |
| | | } |
| | | else { |
| | | LOGE("è·åCC-Linkçæ¬ä¿¡æ¯å¤±è´¥."); |
| | |
| | | BoardStatus status; |
| | | nRet = m_cclink.GetBoardStatus(status); |
| | | if (nRet == 0) { |
| | | LOGI("ç¶æï¼%s.", status.toString().c_str()); |
| | | LOGD("ç¶æï¼%s.", status.toString().c_str()); |
| | | } |
| | | else { |
| | | LOGE("è·åCC-Linkç¶æå¤±è´¥."); |
| | |
| | | TRACE("a0001\n", writeCode, retCode); |
| | | }); |
| | | if (nRet != 0) { |
| | | LOGI("<Master>EFEM忢Startç¶æå¤±è´¥"); |
| | | LOGE("<Master>EFEM忢Startç¶æå¤±è´¥"); |
| | | m_strLastError = "EFEM忢Startç¶æå¤±è´¥."; |
| | | goto WAIT; |
| | | } |
| | |
| | | TRACE("a0002\n"); |
| | | }); |
| | | if (nRet != 0) { |
| | | LOGI("<Master>Bonder1忢Startç¶æå¤±è´¥"); |
| | | LOGE("<Master>Bonder1忢Startç¶æå¤±è´¥"); |
| | | m_strLastError = "Bonder1忢Startç¶æå¤±è´¥."; |
| | | goto WAIT; |
| | | } |
| | |
| | | TRACE("a0003\n"); |
| | | }); |
| | | if (nRet != 0) { |
| | | LOGI("<Master>Bonder2忢Startç¶æå¤±è´¥"); |
| | | LOGE("<Master>Bonder2忢Startç¶æå¤±è´¥"); |
| | | m_strLastError = "Bonder2忢Startç¶æå¤±è´¥."; |
| | | goto WAIT; |
| | | } |
| | |
| | | TRACE("a0004\n"); |
| | | }); |
| | | if (nRet != 0) { |
| | | LOGI("<Master>BakeCooling忢Startç¶æå¤±è´¥"); |
| | | LOGE("<Master>BakeCooling忢Startç¶æå¤±è´¥"); |
| | | m_strLastError = "BakeCooling忢Startç¶æå¤±è´¥."; |
| | | goto WAIT; |
| | | } |
| | |
| | | TRACE("a0005\n"); |
| | | }); |
| | | if (nRet != 0) { |
| | | LOGI("<Master>VacuumBake忢Startç¶æå¤±è´¥"); |
| | | LOGE("<Master>VacuumBake忢Startç¶æå¤±è´¥"); |
| | | m_strLastError = "VacuumBake忢Startç¶æå¤±è´¥."; |
| | | goto WAIT; |
| | | } |
| | |
| | | TRACE("a0006\n"); |
| | | }); |
| | | if (nRet != 0) { |
| | | LOGI("<Master>Measurement忢Startç¶æå¤±è´¥"); |
| | | LOGE("<Master>Measurement忢Startç¶æå¤±è´¥"); |
| | | m_strLastError = "Measurement忢Startç¶æå¤±è´¥."; |
| | | goto WAIT; |
| | | } |
| | |
| | | for (int i = 0; i < 6; i++) { |
| | | if (!bIomcOk[i]) { |
| | | bIomcOk[6] = FALSE; |
| | | LOGI("<Master>%s忢Startç¶æå¤±è´¥", pEq[i]->getName().c_str()); |
| | | LOGE("<Master>%s忢Startç¶æå¤±è´¥", pEq[i]->getName().c_str()); |
| | | } |
| | | } |
| | | |
| | |
| | | TRACE("s000%d: ret=%d\n", i + 1, retCode); |
| | | }); |
| | | if (nRet != 0) { |
| | | LOGI("<Master>%s忢Stopç¶æåé失败", pEq[i]->getName().c_str()); |
| | | LOGE("<Master>%s忢Stopç¶æåé失败", pEq[i]->getName().c_str()); |
| | | m_strLastError = pEq[i]->getName() + "忢Stopç¶æåé失败."; |
| | | bIomcOk[i] = FALSE; |
| | | promises[i].set_value(); // é¿å
wait é»å¡ |
| | |
| | | for (int i = 0; i < 6; ++i) { |
| | | if (!bIomcOk[i]) { |
| | | bIomcOk[6] = FALSE; |
| | | LOGI("<Master>%s忢Stopç¶æå¤±è´¥", pEq[i]->getName().c_str()); |
| | | LOGE("<Master>%s忢Stopç¶æå¤±è´¥", pEq[i]->getName().c_str()); |
| | | } |
| | | } |
| | | |
| | |
| | | |
| | | if (!rmd.armState[0]) { |
| | | // m_nTestFlag = 1; |
| | | if (m_nTestFlag == 1) LOGI("createTransferTask 004df %d, %d", MaterialsType::G1, secondaryType); |
| | | if (m_nTestFlag == 1) LOGD("createTransferTask 004df %d, %d", MaterialsType::G1, secondaryType); |
| | | m_pActiveRobotTask = createTransferTask(pAligner, pVacuumBake, MaterialsType::G1, secondaryType); |
| | | CHECK_RUN_ACTIVE_ROBOT_TASK(m_pActiveRobotTask); |
| | | m_nTestFlag = 0; |
| | |
| | | CJState state = m_pControlJob->state(); |
| | | if (state == CJState::Completed || state == CJState::Aborted || state == CJState::Failed) { |
| | | // ConrolJpb已宿 |
| | | LOGI("<Master>ControlJobå·²ç»å®ææå¤±è´¥ä¸æ"); |
| | | LOGE("<Master>ControlJobå·²ç»å®ææå¤±è´¥ä¸æ"); |
| | | unlock(); |
| | | continue; |
| | | } |
| | |
| | | } |
| | | } |
| | | if (m_inProcesJobs.empty()) { |
| | | LOGI("<Master>éæ©å½åProcessJob失败ï¼"); |
| | | LOGE("<Master>éæ©å½åProcessJob失败ï¼"); |
| | | unlock(); |
| | | continue; |
| | | } |
| | |
| | | |
| | | // Measurement -> LoadPort |
| | | if (rmd.armState[0] || rmd.armState[1]) { |
| | | LOGI("Arm1 %s, Arm2 %s.", rmd.armState[0] ? _T("ä¸å¯ç¨") : _T("å¯ç¨"), |
| | | LOGD("Arm1 %s, Arm2 %s.", rmd.armState[0] ? _T("ä¸å¯ç¨") : _T("å¯ç¨"), |
| | | rmd.armState[1] ? _T("ä¸å¯ç¨") : _T("å¯ç¨")); |
| | | } |
| | | for (int s = 0; s < 4; s++) { |
| | |
| | | BOOL bOk = FALSE; |
| | | lock(); |
| | | if (m_pActiveRobotTask != nullptr) { |
| | | LOGI("<CMaster>onPreFethedOutJob 0001."); |
| | | LOGD("<CMaster>onPreFethedOutJob 0001."); |
| | | if (m_pActiveRobotTask->getSrcPosition() == p->getID()) { |
| | | LOGI("<CMaster>onPreFethedOutJob 0002."); |
| | | LOGD("<CMaster>onPreFethedOutJob 0002."); |
| | | CGlass* pGlass = p->getGlassFromSlot(m_pActiveRobotTask->getSrcSlot()); |
| | | if (pGlass != nullptr) { |
| | | LOGI("<CMaster>onPreFethedOutJob 0003."); |
| | | LOGD("<CMaster>onPreFethedOutJob 0003."); |
| | | CJobDataS* pJobDataS = pGlass->getJobDataS(); |
| | | if (pJobDataS != nullptr |
| | | && pJobDataS->getCassetteSequenceNo() == pJobDataB->getCassetteSequenceNo() |
| | | && pJobDataS->getJobSequenceNo() == pJobDataB->getJobSequenceNo()) { |
| | | bOk = TRUE; |
| | | LOGI("<CMaster>onPreFethedOutJob, å·²æ ¡éªæ°æ®ä¸è´æ§."); |
| | | LOGD("<CMaster>onPreFethedOutJob, å·²æ ¡éªæ°æ®ä¸è´æ§."); |
| | | } |
| | | LOGI("<CMaster>onPreFethedOutJob 0004."); |
| | | LOGD("<CMaster>onPreFethedOutJob 0004."); |
| | | if (pJobDataS != nullptr) { |
| | | LOGI("<CMaster>onPreFethedOutJob 0005. %d,%d,%d,%d", |
| | | LOGD("<CMaster>onPreFethedOutJob 0005. %d,%d,%d,%d", |
| | | pJobDataS->getCassetteSequenceNo(), |
| | | pJobDataB->getCassetteSequenceNo(), |
| | | pJobDataS->getJobSequenceNo(), |
| | |
| | | if (m_listener.onLoadPortStatusChanged != nullptr) { |
| | | m_listener.onLoadPortStatusChanged(this, (CEquipment*)pEquipment, status, data); |
| | | } |
| | | }; |
| | | listener.onSVDataReport = [&](void* pEquipment, void* pData) { |
| | | CSVData* pSVData = (CSVData*)pData; |
| | | auto rawData = pSVData->getSVRawData(); |
| | | std::vector<CParam> params; |
| | | ((CEquipment*)pEquipment)->parsingSVData((const char*)rawData.data(), rawData.size(), params); |
| | | |
| | | std::string strOut; |
| | | char szBuffer[256]; |
| | | for (auto p : params) { |
| | | if (!strOut.empty()) strOut.append(","); |
| | | if (p.getValueType() == PVT_INT) { |
| | | sprintf_s(szBuffer, 256, "%s:%d", p.getName().c_str(), p.getIntValue()); |
| | | } |
| | | else if (p.getValueType() == PVT_DOUBLE) { |
| | | sprintf_s(szBuffer, 256, "%s:%f", p.getName().c_str(), p.getDoubleValue()); |
| | | } |
| | | strOut.append(szBuffer); |
| | | } |
| | | LOGD("<CMaster-%s>SVDataReport:%s", ((CEquipment*)pEquipment)->getName().c_str(), strOut.c_str()); |
| | | }; |
| | | pEquipment->setListener(listener); |
| | | pEquipment->setCcLink(&m_cclink); |
| | |
| | | pSrcEq->m_nTestFlag = m_nTestFlag; |
| | | pTarSlot = pTarEq->getAvailableSlotForGlass(primaryType); |
| | | pSrcSlot = pSrcEq->getProcessedSlot(primaryType, bJobMode); |
| | | if (m_nTestFlag == 1) LOGI("createTransferTask 003 %x, %x", pTarSlot, pSrcSlot); |
| | | if (m_nTestFlag == 1) LOGD("createTransferTask 003 %x, %x", pTarSlot, pSrcSlot); |
| | | if (pSrcSlot == nullptr || nullptr == pTarSlot && secondaryType != SERVO::MaterialsType::G0) { |
| | | pTarSlot = pTarEq->getAvailableSlotForGlass(secondaryType); |
| | | pSrcSlot = pSrcEq->getProcessedSlot(secondaryType, bJobMode); |
| | | } |
| | | if (m_nTestFlag == 1) LOGI("createTransferTask 004 %x, %x", pTarSlot, pSrcSlot); |
| | | if (m_nTestFlag == 1) LOGD("createTransferTask 004 %x, %x", pTarSlot, pSrcSlot); |
| | | |
| | | if (pSrcSlot != nullptr && nullptr != pTarSlot) { |
| | | pTask = new CRobotTask(); |
| | |
| | | |
| | | return nullptr; |
| | | } |
| | | |
| | | int CMaster::getWipGlasses(std::vector<CGlass*>& glasses) |
| | | { |
| | | for (auto eq : m_listEquipment) { |
| | | auto p = dynamic_cast<CLoadPort*>(eq); |
| | | if (p == nullptr) { |
| | | eq->getAllGlass(glasses); |
| | | } |
| | | |
| | | } |
| | | |
| | | return (int)glasses.size(); |
| | | } |
| | | } |
| | |
| | | CLoadPort* getPortWithCarrierId(const std::string& carrierId) const; |
| | | bool saveState() const; |
| | | bool loadState(const std::string& path); |
| | | int getWipGlasses(std::vector<CGlass*>& glasses); |
| | | |
| | | private: |
| | | inline void lock() { EnterCriticalSection(&m_criticalSection); } |
| | |
| | | } |
| | | } |
| | | |
| | | // FAC Data Report |
| | | addFacDataReportStep(0x1a589, 0xf4d, 1); |
| | | /* |
| | | { |
| | | CEqReadStep* pStep = new CEqReadStep(0x1a589, 133 * 2, |
| | | [&](void* pFrom, int code, const char* pszData, size_t size) -> int { |
| | | if (code == ROK && pszData != nullptr && size > 0) { |
| | | decodeFacDataReport((CStep*)pFrom, pszData, size); |
| | | } |
| | | return -1; |
| | | }); |
| | | pStep->setName(STEP_EQ_FAC_DATA_REPORT); |
| | | pStep->setProp("Port", (void*)1); |
| | | pStep->setWriteSignalDev(0xf4d); |
| | | if (addStep(STEP_ID_FAC_DATA_REPORT, pStep) != 0) { |
| | | delete pStep; |
| | | } |
| | | } |
| | | */ |
| | | |
| | | // process start/end report |
| | | { |
| | | CEqReadStep* pStep = new CEqReadStep(0x19D3F, 13 * 2, |
| | |
| | | |
| | | return (int)params.size(); |
| | | } |
| | | |
| | | int CMeasurement::parsingProcessData(const char* pszData, size_t size, std::vector<CParam>& params) |
| | | { |
| | | return parsingParams(pszData, size, params); |
| | | } |
| | | |
| | | int CMeasurement::parsingSVData(const char* pszData, size_t size, std::vector<CParam>& params) |
| | | { |
| | | /*/ |
| | | 1 å·¥èºè¿è¡æ¥éª¤ 1Word 123456 |
| | | 2 AOIæ£æµé度 2Word 123.456 |
| | | */ |
| | | |
| | | ASSERT(pszData); |
| | | if (size < 125) return 0; |
| | | int i = 0, v; |
| | | |
| | | |
| | | // 1.å·¥èºè¿è¡æ¥éª¤ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8; |
| | | params.push_back(CParam("å·¥èºè¿è¡æ¥éª¤", "", this->getName().c_str(), v)); |
| | | i += 2; |
| | | |
| | | // 2.æ£æµé度 |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8 | (pszData[i + 2] & 0xff) << 16 | (pszData[i + 3] & 0xff) << 24; |
| | | params.push_back(CParam("Aè
温æ§è¡¨1å½åå¼", "", this->getName().c_str(), v * 0.001f)); |
| | | i += 4; |
| | | |
| | | return (int)params.size(); |
| | | } |
| | | |
| | | } |
| | |
| | | virtual int recvIntent(CPin* pPin, CIntent* pIntent); |
| | | virtual int getIndexerOperationModeBaseValue(); |
| | | virtual int parsingParams(const char* pszData, size_t size, std::vector<CParam>& parsms); |
| | | virtual int parsingProcessData(const char* pszData, size_t size, std::vector<CParam>& parsms); |
| | | virtual int parsingSVData(const char* pszData, size_t size, std::vector<CParam>& parsms); |
| | | }; |
| | | } |
| | | |
| | |
| | | LOGI("sendCassetteCtrlCmd æå."); |
| | | } |
| | | else { |
| | | LOGI("sendCassetteCtrlCmd 失败."); |
| | | LOGE("sendCassetteCtrlCmd 失败."); |
| | | } |
| | | |
| | | return 0; |
| | |
| | | #include "CPageGlassList.h" |
| | | #include "afxdialogex.h" |
| | | #include "GlassJson.h" |
| | | #include "CServoUtilsTool.h" |
| | | #include "ToolUnits.h" |
| | | |
| | | #include <optional> |
| | | #include <unordered_set> |
| | | #include <unordered_map> |
| | | #include <vector> |
| | | #include <string> |
| | | |
| | | #define PAGE_SIZE 100 |
| | | #define PAGE_SIZE 50 |
| | | #define PAGE_BACKGROUND_COLOR RGB(252, 252, 255) |
| | | |
| | | // WIP é¢è²ï¼ç¶ï¼æ ¹/æ buddyï¼= åºç¡ç»¿ï¼åï¼buddyï¼= æ´æµ
|
| | | static const COLORREF kWipText = RGB(0, 0, 0); |
| | | static const COLORREF kWipParentBk = RGB(201, 228, 180); // åºç¡ç»¿ |
| | | static const COLORREF kWipChildBk = RGB(221, 241, 208); // æ´æµ
ä¸ç¹ |
| | | |
| | | // ===== æ¾å¨ CPageGlassList.cpp é¡¶é¨çå¿åå·¥å
·ï¼æä»¶å
éæï¼ ===== |
| | | // æå½åâå·²å±å¼âçç¶è¡ï¼ç¨å®ä»¬ç classIdï¼ç¬¬4åææ¬ï¼å key è®°å½ä¸æ¥ |
| | | static std::unordered_set<std::string> SnapshotExpandedKeys(CExpandableListCtrl& lv) { |
| | | std::unordered_set<std::string> keys; |
| | | for (int i = 0; i < lv.GetItemCount(); ++i) { |
| | | auto* n = lv.GetNodeByVisibleIndex(i); |
| | | if (!n || n->children.empty() || !n->expanded) continue; |
| | | if ((int)n->cols.size() > 4) { |
| | | #ifdef _UNICODE |
| | | keys.insert(CT2A(n->cols[4])); |
| | | #else |
| | | keys.insert(n->cols[4].GetString()); |
| | | #endif |
| | | } |
| | | } |
| | | return keys; |
| | | } |
| | | |
| | | // æ ¹æ®å¿«ç
§æ¢å¤å±å¼ç¶æï¼å¨ä½ æ°å»ºå®æ¯ä¸ªâç¶èç¹âæ¶è°ç¨ä¸æ¬¡ï¼ |
| | | static void MaybeRestoreExpandByKey(CExpandableListCtrl::Node* n, |
| | | const std::unordered_set<std::string>& keys) { |
| | | if (!n || (int)n->cols.size() <= 4) return; |
| | | #ifdef _UNICODE |
| | | std::string k = CT2A(n->cols[4]); |
| | | #else |
| | | std::string k = n->cols[4].GetString(); |
| | | #endif |
| | | if (keys.find(k) != keys.end()) |
| | | n->expanded = true; |
| | | } |
| | | |
| | | static void CaptureUiState(CExpandableListCtrl& lv, |
| | | std::vector<CExpandableListCtrl::Node*>& outSel, |
| | | CExpandableListCtrl::Node*& outTopNode) |
| | | { |
| | | outSel.clear(); outTopNode = nullptr; |
| | | const int top = lv.GetTopIndex(); |
| | | if (top >= 0 && top < lv.GetItemCount()) |
| | | outTopNode = lv.GetNodeByVisibleIndex(top); |
| | | for (int i = 0; i < lv.GetItemCount(); ++i) { |
| | | if ((lv.GetItemState(i, LVIS_SELECTED) & LVIS_SELECTED) != 0) { |
| | | auto* n = lv.GetNodeByVisibleIndex(i); |
| | | if (n) outSel.push_back(n); |
| | | } |
| | | } |
| | | } |
| | | static void RestoreUiState(CExpandableListCtrl& lv, |
| | | const std::vector<CExpandableListCtrl::Node*>& sel, |
| | | CExpandableListCtrl::Node* topNode) |
| | | { |
| | | // æ¸
æç°æéæ© |
| | | for (int i = 0; i < lv.GetItemCount(); ++i) |
| | | lv.SetItemState(i, 0, LVIS_SELECTED); |
| | | |
| | | // æ¢å¤éæ© |
| | | for (auto* n : sel) { |
| | | for (int i = 0; i < lv.GetItemCount(); ++i) { |
| | | if (lv.GetNodeByVisibleIndex(i) == n) { |
| | | lv.SetItemState(i, LVIS_SELECTED, LVIS_SELECTED); |
| | | break; |
| | | } |
| | | } |
| | | } |
| | | // å°½éæä¹åçé¡¶è¡æ»åå¯è§ |
| | | if (topNode) { |
| | | for (int i = 0; i < lv.GetItemCount(); ++i) { |
| | | if (lv.GetNodeByVisibleIndex(i) == topNode) { |
| | | lv.EnsureVisible(i, FALSE); |
| | | break; |
| | | } |
| | | } |
| | | } |
| | | } |
| | | |
| | | // ====== å¼å
³ï¼1=å¯ç¨åæ°æ®ï¼åªæ¿æ¢ DB æ¥è¯¢ï¼ï¼0=ç¨çå® DB ====== |
| | | #define USE_FAKE_DB_DEMO 1 |
| | | |
| | | #if USE_FAKE_DB_DEMO |
| | | #include <ctime> |
| | | #include <atlconv.h> // CStringA |
| | | #include <initializer_list> |
| | | #include <string> |
| | | #include <vector> |
| | | |
| | | // ---- 模æè®°å½/åé¡µç»æï¼å段ä¸ä½ ç°æä»£ç ä¸è´ï¼---- |
| | | struct FakeDbRecord { |
| | | int id; |
| | | int cassetteSeqNo; |
| | | int jobSeqNo; |
| | | std::string classId; |
| | | int materialType; |
| | | int state; |
| | | std::string tStart; |
| | | std::string tEnd; |
| | | std::string buddyId; |
| | | int aoiResult; |
| | | std::string path; |
| | | std::string params; |
| | | }; |
| | | struct FakeDbPage { std::vector<FakeDbRecord> items; }; |
| | | |
| | | // ---- CString -> std::stringï¼ANSIï¼æ¬å°ä»£ç 页ï¼ä»
ç¨äºæµè¯æ¨¡æï¼---- |
| | | static std::string toAnsi(const CString& s) { |
| | | #ifdef _UNICODE |
| | | CStringA a(s); |
| | | return std::string(a.GetString()); |
| | | #else |
| | | return std::string(s.GetString()); |
| | | #endif |
| | | } |
| | | |
| | | // ---- å®å
¨æ¼æ¥å·¥å
·ï¼ä¸ä½¿ç¨è¿ç®ç¬¦ +ï¼é¿å
éè½½/转æ¢é®é¢ï¼---- |
| | | static std::string sjoin(std::initializer_list<std::string> parts) { |
| | | std::string out; |
| | | size_t total = 0; for (const auto& p : parts) total += p.size(); |
| | | out.reserve(total); |
| | | for (const auto& p : parts) out.append(p); |
| | | return out; |
| | | } |
| | | |
| | | // ---- æ¶é´æ ¼å¼å·¥å
·ï¼now + days/minutes åç§» ---- |
| | | static std::string _fmt_time(int daysOff, int minutesOff) { |
| | | using namespace std::chrono; |
| | | auto now = system_clock::now() + hours(24 * daysOff) + minutes(minutesOff); |
| | | std::time_t tt = system_clock::to_time_t(now); |
| | | std::tm tm{}; |
| | | #ifdef _WIN32 |
| | | localtime_s(&tm, &tt); |
| | | #else |
| | | tm = *std::localtime(&tt); |
| | | #endif |
| | | char buf[32]; |
| | | std::snprintf(buf, sizeof(buf), "%04d-%02d-%02d %02d:%02d:%02d", |
| | | tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec); |
| | | return std::string(buf); |
| | | } |
| | | |
| | | // ---- é å
¨éåæ°æ®ï¼å«å页é
对/跨页é
对/åæ¡ï¼---- |
| | | static void _make_all_fake(std::vector<FakeDbRecord>& outAll) { |
| | | outAll.clear(); |
| | | int id = 1000; |
| | | |
| | | // ===== å
é å æ¡â没æ Buddyâçè®°å½ï¼ä¿è¯åºç°å¨ç¬¬ 1 页å¼å¤´ï¼===== |
| | | for (int n = 1; n <= 4; ++n) { |
| | | CString cid; cid.Format(_T("NB%03d"), n); |
| | | outAll.push_back(FakeDbRecord{ |
| | | id++, 700 + n, 800 + n, toAnsi(cid), |
| | | n % 3, n % 5, |
| | | _fmt_time(0, -n * 5), // å¼å§æ¶é´ç¨æ©ä¸ç¹ |
| | | _fmt_time(0, -n * 5 + 1), |
| | | std::string(), // buddyId 为空 |
| | | n % 4, |
| | | sjoin({ "path/", toAnsi(cid) }), |
| | | sjoin({ "{\"noBuddy\":", std::to_string(n), "}" }) |
| | | }); |
| | | } |
| | | |
| | | // ===== é é
å¯¹æ°æ®çå·¥å
· ===== |
| | | auto mkPair = [&](int k, bool crossPage) { |
| | | // äºä¸º buddy çä¸¤æ¡ |
| | | CString a; a.Format(_T("G%04dA"), k); |
| | | CString b; b.Format(_T("G%04dB"), k); |
| | | |
| | | FakeDbRecord A{ |
| | | id++, 100 + k, 200 + k, toAnsi(a), |
| | | k % 3, k % 5, _fmt_time(0, k * 3), _fmt_time(0, k * 3 + 2), |
| | | toAnsi(b), k % 4, |
| | | sjoin({ "path/", toAnsi(a) }), |
| | | sjoin({ "{\"k\":\"", toAnsi(a), "\"}" }) |
| | | }; |
| | | FakeDbRecord B{ |
| | | id++, 110 + k, 210 + k, toAnsi(b), |
| | | (k + 1) % 3, (k + 2) % 5, _fmt_time(0, k * 3 + 1), _fmt_time(0, k * 3 + 4), |
| | | toAnsi(a), (k + 1) % 4, |
| | | sjoin({ "path/", toAnsi(b) }), |
| | | sjoin({ "{\"k\":\"", toAnsi(b), "\"}" }) |
| | | }; |
| | | |
| | | if (crossPage) { |
| | | // å
æ¾ Aï¼åæ 3 æ¡âåæ¡âæ B æ¤å°åé¡µï¼æåæ¾ B |
| | | outAll.push_back(A); |
| | | for (int s = 0; s < 3; ++s) { |
| | | CString sid; sid.Format(_T("S%04d_%d"), k, s); |
| | | outAll.push_back(FakeDbRecord{ |
| | | id++, 300 + k * 10 + s, 400 + k * 10 + s, toAnsi(sid), |
| | | (k + s) % 3, (k + s) % 5, _fmt_time(0, k * 2 + s), _fmt_time(0, k * 2 + s + 1), |
| | | std::string(), (k + s) % 4, |
| | | sjoin({ "path/", toAnsi(sid) }), |
| | | sjoin({ "{\"single\":", std::to_string(s), "}" }) |
| | | }); |
| | | } |
| | | outAll.push_back(B); |
| | | } |
| | | else { |
| | | // å页紧æ¨ç |
| | | outAll.push_back(A); |
| | | outAll.push_back(B); |
| | | } |
| | | }; |
| | | |
| | | // ===== ç¶åæåé»è¾è¿½å ï¼å页é
对 / 跨页é
坹 / 忡 ===== |
| | | // 6 ç»å页é
对ï¼12 æ¡ï¼ |
| | | for (int k = 1; k <= 6; ++k) mkPair(k, false); |
| | | // 4 ç»è·¨é¡µé
å¯¹ï¼æ¯ç»ä¸é´æ 3 æ¡âåæ¡âï¼ |
| | | for (int k = 101; k <= 104; ++k) mkPair(k, true); |
| | | // è¥å¹²âåæ¡â |
| | | for (int u = 201; u < 806; ++u) { |
| | | CString cid; cid.Format(_T("U%04d"), u); |
| | | outAll.push_back(FakeDbRecord{ |
| | | id++, 500 + u, 600 + u, toAnsi(cid), |
| | | u % 3, u % 5, _fmt_time(0, u % 17), _fmt_time(0, (u % 17) + 1), |
| | | std::string(), u % 4, |
| | | sjoin({ "path/", toAnsi(cid) }), |
| | | sjoin({ "{\"u\":", std::to_string(u), "}" }) |
| | | }); |
| | | } |
| | | } |
| | | |
| | | |
| | | // ---- åå页åçï¼å¯æéå æ´ä¸¥æ ¼ç filtersï¼---- |
| | | static FakeDbPage _make_page_fake(const GlassLogDb::Filters& /*f*/, int pageSize, int offset) { |
| | | std::vector<FakeDbRecord> all; |
| | | _make_all_fake(all); |
| | | |
| | | FakeDbPage page; |
| | | int n = (int)all.size(); |
| | | int beg = min(max(0, offset), n); |
| | | int end = min(beg + max(0, pageSize), n); |
| | | page.items.insert(page.items.end(), all.begin() + beg, all.begin() + end); |
| | | return page; |
| | | } |
| | | static int _fake_total_count() { |
| | | std::vector<FakeDbRecord> all; |
| | | _make_all_fake(all); |
| | | return (int)all.size(); |
| | | } |
| | | #endif // USE_FAKE_DB_DEMO |
| | | |
| | | // 夿æ parent 䏿¯å¦å·²åå¨ classId == cid çåèç¹ï¼å¿½ç¥å¤§å°åï¼ |
| | | static bool NodeHasChildWithClassId(CExpandableListCtrl::Node* parent, const CString& cid) |
| | | { |
| | | if (!parent) return false; |
| | | for (auto& ch : parent->children) { |
| | | if (ch && ch->cols.size() > 4) { |
| | | if (ch->cols[4].CompareNoCase(cid) == 0) |
| | | return true; |
| | | } |
| | | } |
| | | return false; |
| | | } |
| | | |
| | | // æ cols ååå°æä¸è¡ï¼ä»ç¬¬1åå¼å§ï¼ç¬¬0åæä»¬æ²¡ç¨ï¼ |
| | | static void ApplyColsToRow(CListCtrl& lv, int row, const std::vector<CString>& cols) { |
| | | int colCount = 0; |
| | | if (auto* hdr = lv.GetHeaderCtrl()) colCount = hdr->GetItemCount(); |
| | | colCount = min(colCount, (int)cols.size()); |
| | | for (int c = 1; c < colCount; ++c) { |
| | | lv.SetItemText(row, c, cols[c]); |
| | | } |
| | | } |
| | | |
| | | // éä¸è¡ç ClassID å¿«ç
§ï¼ç¨äºéå»ºåæ¢å¤ï¼ |
| | | static std::unordered_set<std::string> SnapshotSelectedKeys(CListCtrl& lv) { |
| | | std::unordered_set<std::string> keys; |
| | | int n = lv.GetItemCount(); |
| | | for (int i = 0; i < n; ++i) { |
| | | if ((lv.GetItemState(i, LVIS_SELECTED) & LVIS_SELECTED) == 0) continue; |
| | | CString cls = lv.GetItemText(i, 4); |
| | | #ifdef _UNICODE |
| | | keys.insert(CT2A(cls)); |
| | | #else |
| | | keys.insert(cls.GetString()); |
| | | #endif |
| | | } |
| | | return keys; |
| | | } |
| | | |
| | | // é¡¶è¡ï¼TopIndexï¼å¯¹åºç ClassID |
| | | static std::optional<std::string> SnapshotTopKey(CListCtrl& lv) { |
| | | int top = lv.GetTopIndex(); |
| | | if (top < 0 || top >= lv.GetItemCount()) return std::nullopt; |
| | | CString cls = lv.GetItemText(top, 4); |
| | | #ifdef _UNICODE |
| | | return std::optional<std::string>(CT2A(cls)); |
| | | #else |
| | | return std::optional<std::string>(cls.GetString()); |
| | | #endif |
| | | } |
| | | |
| | | // ç¨ ClassID é忢å¤éä¸ |
| | | static void RestoreSelectionByKeys(CListCtrl& lv, const std::unordered_set<std::string>& keys) { |
| | | int n = lv.GetItemCount(); |
| | | for (int i = 0; i < n; ++i) lv.SetItemState(i, 0, LVIS_SELECTED); |
| | | for (int i = 0; i < n; ++i) { |
| | | CString cls = lv.GetItemText(i, 4); |
| | | #ifdef _UNICODE |
| | | if (keys.count(CT2A(cls))) lv.SetItemState(i, LVIS_SELECTED, LVIS_SELECTED); |
| | | #else |
| | | if (keys.count(cls.GetString())) lv.SetItemState(i, LVIS_SELECTED, LVIS_SELECTED); |
| | | #endif |
| | | } |
| | | } |
| | | |
| | | // å°½éææä¸ª ClassID æ»åå¯è§ |
| | | static void RestoreTopByKey(CListCtrl& lv, const std::optional<std::string>& key) { |
| | | if (!key) return; |
| | | int n = lv.GetItemCount(); |
| | | for (int i = 0; i < n; ++i) { |
| | | CString cls = lv.GetItemText(i, 4); |
| | | #ifdef _UNICODE |
| | | if (CT2A(cls) == *key) { lv.EnsureVisible(i, FALSE); break; } |
| | | #else |
| | | if (cls.GetString() == *key) { lv.EnsureVisible(i, FALSE); break; } |
| | | #endif |
| | | } |
| | | } |
| | | |
| | | // CPageGlassList å¯¹è¯æ¡ |
| | | |
| | |
| | | m_pObserver = nullptr; |
| | | |
| | | m_strStatus = ""; |
| | | m_strKeyword = ""; |
| | | m_nCurPage = 0; |
| | | m_nTotalPages = 0; |
| | | m_nCurPage = 1; |
| | | m_nTotalPages = 1; |
| | | |
| | | memset(m_szTimeStart, 0, sizeof(m_szTimeStart)); |
| | | memset(m_szTimeEnd, 0, sizeof(m_szTimeEnd)); |
| | |
| | | { |
| | | if (m_hbrBkgnd != nullptr) { |
| | | ::DeleteObject(m_hbrBkgnd); |
| | | m_hbrBkgnd = nullptr; |
| | | } |
| | | if (m_pObserver != nullptr) { |
| | | m_pObserver->unsubscribe(); |
| | |
| | | DDX_Control(pDX, IDC_LIST_ALARM, m_listCtrl); |
| | | } |
| | | |
| | | |
| | | BEGIN_MESSAGE_MAP(CPageGlassList, CDialogEx) |
| | | ON_WM_CTLCOLOR() |
| | | ON_WM_DESTROY() |
| | |
| | | ON_BN_CLICKED(IDC_BUTTON_NEXT_PAGE, &CPageGlassList::OnBnClickedButtonNextPage) |
| | | END_MESSAGE_MAP() |
| | | |
| | | // ===== ç§æå°å·¥å
· ===== |
| | | static int GetColumnCount(CListCtrl& lv) |
| | | { |
| | | CHeaderCtrl* pHdr = lv.GetHeaderCtrl(); |
| | | return pHdr ? pHdr->GetItemCount() : 0; |
| | | } |
| | | |
| | | // CPageGlassList æ¶æ¯å¤çç¨åº |
| | | // ===== CPageGlassList æ¶æ¯å¤çç¨åº ===== |
| | | void CPageGlassList::InitRxWindow() |
| | | { |
| | | /* code */ |
| | | // 订é
æ°æ® |
| | | IRxWindows* pRxWindows = RX_GetRxWindows(); |
| | | pRxWindows->enableLog(5); |
| | |
| | | int code = pAny->getCode(); |
| | | |
| | | if (RX_CODE_EQ_ROBOT_TASK == code) { |
| | | UpdatePageData(); |
| | | UpdateWipData(); // åªæ´æ°ï¼ä¸é建ï¼ä¸æ¹åå±å¼/éæ© |
| | | } |
| | | |
| | | pAny->release(); |
| | | }, [&]() -> void { |
| | | // onComplete |
| | | }, [&](IThrowable* pThrowable) -> void { |
| | | // onErrorm |
| | | // onError |
| | | pThrowable->printf(); |
| | | }); |
| | | |
| | |
| | | CWnd* pLabelPage = GetDlgItem(IDC_LABEL_PAGE_NUMBER); |
| | | |
| | | if (pBtnNext && pBtnPrev && pLabelPage) { |
| | | // è·ååé¡µææ¬å®½åº¦ä¼°ç® |
| | | //CString strLabel; |
| | | //GetDlgItemText(IDC_LABEL_PAGE_NUMBER, strLabel); |
| | | //if (strLabel.IsEmpty()) { |
| | | // strLabel = _T("第 1 / 1 页"); |
| | | //} |
| | | //int nCharWidth = 8; |
| | | //int nLabelWidth = strLabel.GetLength() * nCharWidth + 20; |
| | | |
| | | // 设置æé®åæ ç¾ä½ç½® |
| | | pBtnNext->MoveWindow(xRight - nButtonWidth, yBottom, nButtonWidth, nButtonHeight); |
| | | xRight -= nButtonWidth + nSpacing; |
| | | |
| | |
| | | if (m_dateTimeStart.m_hWnd == nullptr || m_dateTimeEnd.m_hWnd == nullptr) { |
| | | return; |
| | | } |
| | | |
| | | // ç¦ç¨åå§ç¶æ |
| | | // èªå®ä¹èå´æ¶æå¯ç¼è¾ |
| | | m_dateTimeStart.EnableWindow(FALSE); |
| | | m_dateTimeEnd.EnableWindow(FALSE); |
| | | |
| | | // è®¾ç½®æ ¼å¼ï¼æ¾ç¤ºæ¥æ + æ¶é´ |
| | | //m_dateTimeStart.SetFormat(_T("yyyy/MM/dd HH:mm:ss")); |
| | | //m_dateTimeEnd.SetFormat(_T("yyyy/MM/dd HH:mm:ss")); |
| | | |
| | | // ä¿®æ¹æ ·å¼ä»¥æ¯ææ¶é´æ ¼å¼ |
| | | //DWORD dwStyleStart = m_dateTimeStart.GetStyle(); |
| | | //DWORD dwStyleEnd = m_dateTimeEnd.GetStyle(); |
| | | |
| | | //m_dateTimeStart.ModifyStyle(0, DTS_TIMEFORMAT | DTS_UPDOWN); |
| | | //m_dateTimeEnd.ModifyStyle(0, DTS_TIMEFORMAT); |
| | | } |
| | | |
| | | void CPageGlassList::LoadTransfers() |
| | | void CPageGlassList::LoadData() |
| | | { |
| | | m_nCurPage = 1; |
| | | UpdatePageData(); |
| | |
| | | |
| | | void CPageGlassList::UpdatePageData() |
| | | { |
| | | /* |
| | | TransferData filter; |
| | | filter.strStatus = m_strStatus; |
| | | filter.strDescription = m_strKeyword; |
| | | filter.strCreateTime = m_szTimeStart; |
| | | filter.strEndTime = m_szTimeEnd; |
| | | auto vecData = TransferManager::getInstance().getTransfers(filter, m_nCurPage, PAGE_SIZE); |
| | | FillDataToListCtrl(vecData); |
| | | m_rebuilding = true; |
| | | |
| | | int nTotalRecords = TransferManager::getInstance().getFilteredTransferCount(filter); |
| | | m_nTotalPages = (nTotalRecords + PAGE_SIZE - 1) / PAGE_SIZE; |
| | | // æ¾å¨ä»»ä½æ¸
空/é建å¨ä½ä¹åï¼ |
| | | auto expandedKeys = SnapshotExpandedKeys(m_listCtrl); |
| | | |
| | | // ââ åä¿é©ï¼å
æ¸
æå¯è§é¡¹ï¼åæ¸
æ ç»æ ââ |
| | | m_listCtrl.SetRedraw(FALSE); |
| | | m_listCtrl.DeleteAllItems(); |
| | | m_listCtrl.SetRedraw(TRUE); |
| | | |
| | | // ââ æ¸
空æ ï¼ä¾èµ CExpandableListCtrl::ClearTree()ï¼ââ |
| | | m_listCtrl.ClearTree(); |
| | | |
| | | const int colCount = m_listCtrl.GetHeaderCtrl() ? m_listCtrl.GetHeaderCtrl()->GetItemCount() : 0; |
| | | if (colCount <= 0) return; |
| | | |
| | | // ==================== 1) WIPï¼ä»
第 1 页æå»ºï¼ä¸æ¾å¨æé¡¶é¨ ==================== |
| | | if (m_nCurPage == 1) { |
| | | std::vector<SERVO::CGlass*> wipGlasses; |
| | | theApp.m_model.m_master.getWipGlasses(wipGlasses); |
| | | std::vector<SERVO::CGlass*> tempGlasses = wipGlasses; // å¾
éæ¾ |
| | | |
| | | auto glassHit = [&](SERVO::CGlass* g) -> bool { |
| | | return g && GlassMatchesFilters(*g, m_filters); |
| | | }; |
| | | |
| | | std::unordered_set<SERVO::CGlass*> usedWip; |
| | | |
| | | for (auto* g : wipGlasses) { |
| | | if (!glassHit(g) || usedWip.count(g)) continue; |
| | | |
| | | SERVO::CGlass* b = g->getBuddy(); |
| | | if (b) { |
| | | SERVO::CGlass* parent = g; |
| | | SERVO::CGlass* child = b; |
| | | |
| | | std::vector<CString> pcols(colCount); |
| | | pcols[1] = _T(""); |
| | | pcols[2] = std::to_string(parent->getCassetteSequenceNo()).c_str(); |
| | | pcols[3] = std::to_string(parent->getJobSequenceNo()).c_str(); |
| | | pcols[4] = parent->getID().c_str(); |
| | | pcols[5] = SERVO::CServoUtilsTool::getMaterialsTypeText(parent->getType()).c_str(); |
| | | pcols[6] = SERVO::CServoUtilsTool::getGlassStateText(parent->state()).c_str(); |
| | | pcols[7] = CToolUnits::TimePointToLocalString(parent->tStart()).c_str(); |
| | | pcols[8] = CToolUnits::TimePointToLocalString(parent->tEnd()).c_str(); |
| | | pcols[9] = parent->getBuddyId().c_str(); |
| | | pcols[10] = SERVO::CServoUtilsTool::getInspResultText((SERVO::InspResult)parent->getAOIInspResult()).c_str(); |
| | | pcols[11] = parent->getPathDescription().c_str(); |
| | | pcols[12] = parent->getParamsDescription().c_str(); |
| | | |
| | | auto* nParent = m_listCtrl.InsertRoot(pcols); |
| | | MaybeRestoreExpandByKey(nParent, expandedKeys); |
| | | m_listCtrl.SetNodeColor(nParent, kWipText, kWipParentBk); // ç¶ï¼åºç¡ç»¿ |
| | | |
| | | std::vector<CString> ccols(colCount); |
| | | ccols[1] = _T(""); |
| | | ccols[2] = std::to_string(child->getCassetteSequenceNo()).c_str(); |
| | | ccols[3] = std::to_string(child->getJobSequenceNo()).c_str(); |
| | | ccols[4] = child->getID().c_str(); |
| | | ccols[5] = SERVO::CServoUtilsTool::getMaterialsTypeText(child->getType()).c_str(); |
| | | ccols[6] = SERVO::CServoUtilsTool::getGlassStateText(child->state()).c_str(); |
| | | ccols[7] = CToolUnits::TimePointToLocalString(child->tStart()).c_str(); |
| | | ccols[8] = CToolUnits::TimePointToLocalString(child->tEnd()).c_str(); |
| | | ccols[9] = child->getBuddyId().c_str(); |
| | | ccols[10] = SERVO::CServoUtilsTool::getInspResultText((SERVO::InspResult)child->getAOIInspResult()).c_str(); |
| | | ccols[11] = child->getPathDescription().c_str(); |
| | | ccols[12] = child->getParamsDescription().c_str(); |
| | | |
| | | auto* nChild = m_listCtrl.InsertChild(nParent, ccols); |
| | | m_listCtrl.SetNodeColor(nChild, kWipText, kWipChildBk); // åï¼æ´æµ
|
| | | |
| | | usedWip.insert(parent); |
| | | usedWip.insert(child); |
| | | } |
| | | else { |
| | | std::vector<CString> cols(colCount); |
| | | cols[1] = _T(""); |
| | | cols[2] = std::to_string(g->getCassetteSequenceNo()).c_str(); |
| | | cols[3] = std::to_string(g->getJobSequenceNo()).c_str(); |
| | | cols[4] = g->getID().c_str(); |
| | | cols[5] = SERVO::CServoUtilsTool::getMaterialsTypeText(g->getType()).c_str(); |
| | | cols[6] = SERVO::CServoUtilsTool::getGlassStateText(g->state()).c_str(); |
| | | cols[7] = CToolUnits::TimePointToLocalString(g->tStart()).c_str(); |
| | | cols[8] = CToolUnits::TimePointToLocalString(g->tEnd()).c_str(); |
| | | cols[9] = g->getBuddyId().c_str(); |
| | | cols[10] = SERVO::CServoUtilsTool::getInspResultText((SERVO::InspResult)g->getAOIInspResult()).c_str(); |
| | | cols[11] = g->getPathDescription().c_str(); |
| | | cols[12] = g->getParamsDescription().c_str(); |
| | | |
| | | auto* n = m_listCtrl.InsertRoot(cols); |
| | | m_listCtrl.SetNodeColor(n, kWipText, kWipParentBk); // ä»ç¨åºç¡ç»¿ |
| | | usedWip.insert(g); |
| | | } |
| | | } |
| | | for (auto* item : tempGlasses) item->release(); |
| | | } |
| | | |
| | | // ==================== 2) DB å½åé¡µï¼æ 论第å é¡µé½æå»ºï¼æå¨ WIP ä¹åï¼ ==================== |
| | | #if USE_FAKE_DB_DEMO |
| | | auto page = _make_page_fake(m_filters, PAGE_SIZE, PAGE_SIZE * (m_nCurPage - 1)); |
| | | #else |
| | | auto& db = GlassLogDb::Instance(); |
| | | auto page = db.queryPaged(m_filters, PAGE_SIZE, PAGE_SIZE * (m_nCurPage - 1)); |
| | | #endif |
| | | |
| | | std::unordered_map<std::string, size_t> idxById; |
| | | idxById.reserve(page.items.size()); |
| | | for (size_t i = 0; i < page.items.size(); ++i) idxById[page.items[i].classId] = i; |
| | | |
| | | std::unordered_set<std::string> usedDb; |
| | | int zebra = 0; |
| | | |
| | | for (size_t i = 0; i < page.items.size(); ++i) { |
| | | const auto& r = page.items[i]; |
| | | if (usedDb.count(r.classId)) continue; |
| | | |
| | | COLORREF bk = (zebra % 2 == 0) ? RGB(255, 255, 255) : RGB(235, 235, 235); |
| | | bool paired = false; |
| | | |
| | | if (!r.buddyId.empty()) { |
| | | auto it = idxById.find(r.buddyId); |
| | | if (it != idxById.end()) { |
| | | const auto& br = page.items[it->second]; |
| | | if (!usedDb.count(br.classId)) { |
| | | bool rIsParent = (r.classId <= br.classId); |
| | | const auto& parentRec = rIsParent ? r : br; |
| | | const auto& childRec = rIsParent ? br : r; |
| | | |
| | | std::vector<CString> pcols(colCount); |
| | | pcols[1] = std::to_string(parentRec.id).c_str(); pcols[2] = std::to_string(parentRec.cassetteSeqNo).c_str(); |
| | | pcols[3] = std::to_string(parentRec.jobSeqNo).c_str(); pcols[4] = parentRec.classId.c_str(); |
| | | pcols[5] = SERVO::CServoUtilsTool::getMaterialsTypeText((SERVO::MaterialsType)parentRec.materialType).c_str(); |
| | | pcols[6] = SERVO::CServoUtilsTool::getGlassStateText((SERVO::GlsState)parentRec.state).c_str(); |
| | | pcols[7] = parentRec.tStart.c_str(); pcols[8] = parentRec.tEnd.c_str(); pcols[9] = parentRec.buddyId.c_str(); |
| | | pcols[10] = SERVO::CServoUtilsTool::getInspResultText((SERVO::InspResult)parentRec.aoiResult).c_str(); |
| | | pcols[11] = parentRec.path.c_str(); pcols[12] = parentRec.params.c_str(); |
| | | |
| | | auto* nParent = m_listCtrl.InsertRoot(pcols); |
| | | MaybeRestoreExpandByKey(nParent, expandedKeys); |
| | | m_listCtrl.SetNodeColor(nParent, RGB(0, 0, 0), bk); |
| | | |
| | | std::vector<CString> ccols(colCount); |
| | | ccols[1] = std::to_string(childRec.id).c_str(); ccols[2] = std::to_string(childRec.cassetteSeqNo).c_str(); |
| | | ccols[3] = std::to_string(childRec.jobSeqNo).c_str(); ccols[4] = childRec.classId.c_str(); |
| | | ccols[5] = SERVO::CServoUtilsTool::getMaterialsTypeText((SERVO::MaterialsType)childRec.materialType).c_str(); |
| | | ccols[6] = SERVO::CServoUtilsTool::getGlassStateText((SERVO::GlsState)childRec.state).c_str(); |
| | | ccols[7] = childRec.tStart.c_str(); ccols[8] = childRec.tEnd.c_str(); ccols[9] = childRec.buddyId.c_str(); |
| | | ccols[10] = SERVO::CServoUtilsTool::getInspResultText((SERVO::InspResult)childRec.aoiResult).c_str(); |
| | | ccols[11] = childRec.path.c_str(); ccols[12] = childRec.params.c_str(); |
| | | |
| | | auto* nChild = m_listCtrl.InsertChild(nParent, ccols); |
| | | m_listCtrl.SetNodeColor(nChild, RGB(0, 0, 0), bk); |
| | | |
| | | usedDb.insert(parentRec.classId); |
| | | usedDb.insert(childRec.classId); |
| | | paired = true; |
| | | } |
| | | } |
| | | } |
| | | |
| | | if (!paired && !r.buddyId.empty()) { |
| | | std::vector<CString> pcols(colCount); |
| | | pcols[1] = std::to_string(r.id).c_str(); pcols[2] = std::to_string(r.cassetteSeqNo).c_str(); |
| | | pcols[3] = std::to_string(r.jobSeqNo).c_str(); pcols[4] = r.classId.c_str(); |
| | | pcols[5] = SERVO::CServoUtilsTool::getMaterialsTypeText((SERVO::MaterialsType)r.materialType).c_str(); |
| | | pcols[6] = SERVO::CServoUtilsTool::getGlassStateText((SERVO::GlsState)r.state).c_str(); |
| | | pcols[7] = r.tStart.c_str(); pcols[8] = r.tEnd.c_str(); pcols[9] = r.buddyId.c_str(); |
| | | pcols[10] = SERVO::CServoUtilsTool::getInspResultText((SERVO::InspResult)r.aoiResult).c_str(); |
| | | pcols[11] = r.path.c_str(); pcols[12] = r.params.c_str(); |
| | | |
| | | auto* nParent = m_listCtrl.InsertRoot(pcols); |
| | | MaybeRestoreExpandByKey(nParent, expandedKeys); |
| | | m_listCtrl.SetNodeColor(nParent, RGB(0, 0, 0), bk); |
| | | |
| | | std::vector<CString> ccols(colCount); |
| | | ccols[4] = r.buddyId.c_str(); // å ä½åè¡ï¼æ¾ç¤º buddy ç classId |
| | | auto* nChild = m_listCtrl.InsertChild(nParent, ccols); |
| | | m_listCtrl.SetNodeColor(nChild, RGB(0, 0, 0), bk); |
| | | |
| | | usedDb.insert(r.classId); |
| | | paired = true; |
| | | } |
| | | |
| | | if (!paired) { |
| | | std::vector<CString> cols(colCount); |
| | | cols[1] = std::to_string(r.id).c_str(); cols[2] = std::to_string(r.cassetteSeqNo).c_str(); |
| | | cols[3] = std::to_string(r.jobSeqNo).c_str(); cols[4] = r.classId.c_str(); |
| | | cols[5] = SERVO::CServoUtilsTool::getMaterialsTypeText((SERVO::MaterialsType)r.materialType).c_str(); |
| | | cols[6] = SERVO::CServoUtilsTool::getGlassStateText((SERVO::GlsState)r.state).c_str(); |
| | | cols[7] = r.tStart.c_str(); cols[8] = r.tEnd.c_str(); cols[9] = r.buddyId.c_str(); |
| | | cols[10] = SERVO::CServoUtilsTool::getInspResultText((SERVO::InspResult)r.aoiResult).c_str(); |
| | | cols[11] = r.path.c_str(); cols[12] = r.params.c_str(); |
| | | |
| | | auto* n = m_listCtrl.InsertRoot(cols); |
| | | m_listCtrl.SetNodeColor(n, RGB(0, 0, 0), bk); |
| | | usedDb.insert(r.classId); |
| | | } |
| | | |
| | | ++zebra; |
| | | } |
| | | |
| | | // 䏿¬¡æ§éç» |
| | | m_listCtrl.RebuildVisible(); |
| | | |
| | | // ä¸ä¸é¡µ / ä¸ä¸é¡µ |
| | | UpdatePageControls(); |
| | | */ |
| | | |
| | | m_rebuilding = false; |
| | | } |
| | | |
| | | void CPageGlassList::UpdatePageControls() |
| | |
| | | SetDlgItemText(IDC_LABEL_PAGE_NUMBER, strPage); |
| | | GetDlgItem(IDC_BUTTON_PREV_PAGE)->EnableWindow(m_nCurPage > 1); |
| | | GetDlgItem(IDC_BUTTON_NEXT_PAGE)->EnableWindow(m_nCurPage < m_nTotalPages); |
| | | |
| | | Resize(); |
| | | } |
| | | |
| | | void CPageGlassList::UpdateDateFilter() |
| | | { |
| | | CComboBox* pComboBox = (CComboBox*)GetDlgItem(IDC_COMBO_DATETIME); |
| | | if (nullptr != pComboBox) { |
| | | int nIndex = pComboBox->GetCurSel(); |
| | | if (nIndex == 0) { |
| | | memset(m_szTimeStart, 0, sizeof(m_szTimeStart)); |
| | | memset(m_szTimeEnd, 0, sizeof(m_szTimeEnd)); |
| | | m_szTimeStart[0] = '\0'; |
| | | m_szTimeEnd[0] = '\0'; |
| | | } |
| | | else { |
| | | CTime time = CTime::GetCurrentTime(); |
| | | if (nIndex == 1) { |
| | | sprintf_s(m_szTimeStart, 64, "%d-%02d-%02d 00:00:00", time.GetYear(), time.GetMonth(), time.GetDay()); |
| | | sprintf_s(m_szTimeEnd, 64, "%d-%02d-%02d 23:59:59", time.GetYear(), time.GetMonth(), time.GetDay()); |
| | | } |
| | | else if (nIndex == 2) { |
| | | CTime time2 = time - CTimeSpan(7, 0, 0, 0); |
| | | sprintf_s(m_szTimeStart, 64, "%d-%02d-%02d 00:00:00", time2.GetYear(), time2.GetMonth(), time2.GetDay()); |
| | | sprintf_s(m_szTimeEnd, 64, "%d-%02d-%02d 23:59:59", time.GetYear(), time.GetMonth(), time.GetDay()); |
| | | } |
| | | else if (nIndex == 3) { |
| | | sprintf_s(m_szTimeStart, 64, "%d-%02d-01 00:00:00", time.GetYear(), time.GetMonth()); |
| | | sprintf_s(m_szTimeEnd, 64, "%d-%02d-%02d 23:59:59", time.GetYear(), time.GetMonth(), time.GetDay()); |
| | | } |
| | | else if (nIndex == 4) { |
| | | sprintf_s(m_szTimeStart, 64, "%d-01-01 00:00:00", time.GetYear()); |
| | | sprintf_s(m_szTimeEnd, 64, "%d-12-31 23:59:59", time.GetYear()); |
| | | } |
| | | else if (nIndex == 5) { |
| | | SYSTEMTIME t1, t2; |
| | | m_dateTimeStart.GetTime(&t1); |
| | | m_dateTimeEnd.GetTime(&t2); |
| | | //sprintf_s(m_szTimeStart, 64, "%d-%02d-%02d %02d:%02d:%02d", t1.wYear, t1.wMonth, t1.wDay, t1.wHour, t1.wMinute, t1.wSecond); |
| | | //sprintf_s(m_szTimeEnd, 64, "%d-%02d-%02d %02d:%02d:%02d", t2.wYear, t2.wMonth, t2.wDay, t2.wHour, t2.wMinute, t2.wSecond); |
| | | |
| | | sprintf_s(m_szTimeStart, 64, "%d-%02d-%02d 00:00:00", t1.wYear, t1.wMonth, t1.wDay); |
| | | sprintf_s(m_szTimeEnd, 64, "%d-%02d-%02d 23:59:59", t2.wYear, t2.wMonth, t2.wDay); |
| | | } |
| | | } |
| | | } |
| | | } |
| | | |
| | | /* |
| | | void CPageGlassList::FillDataToListCtrl(const std::vector<TransferData>& vecData) |
| | | { |
| | | if (m_listCtrl.m_hWnd == nullptr) { |
| | | return; |
| | | } |
| | | |
| | | m_listCtrl.DeleteAllItems(); |
| | | for (const auto& item : vecData) { |
| | | InsertTransferData(item); |
| | | } |
| | | } |
| | | |
| | | void CPageGlassList::InsertTransferData(const TransferData& data) |
| | | { |
| | | if (m_listCtrl.m_hWnd == nullptr) { |
| | | return; |
| | | } |
| | | |
| | | int nIndex = m_listCtrl.GetItemCount(); |
| | | if (nIndex < 0) { |
| | | return; |
| | | } |
| | | |
| | | int nItem = m_listCtrl.InsertItem(nIndex, _T("")); |
| | | CString str; |
| | | str.Format(_T("%d"), data.nRecordId); |
| | | m_listCtrl.SetItemText(nItem, 1, str); |
| | | m_listCtrl.SetItemText(nItem, 2, CString(data.strStatus.c_str())); |
| | | m_listCtrl.SetItemText(nItem, 3, CString(data.strClassID.c_str())); |
| | | m_listCtrl.SetItemText(nItem, 4, CString(data.strCreateTime.c_str())); |
| | | m_listCtrl.SetItemText(nItem, 5, CString(data.strPickTime.c_str())); |
| | | m_listCtrl.SetItemText(nItem, 6, CString(data.strPlaceTime.c_str())); |
| | | m_listCtrl.SetItemText(nItem, 7, CString(data.strEndTime.c_str())); |
| | | m_listCtrl.SetItemText(nItem, 8, CString(data.strDescription.c_str())); |
| | | } |
| | | */ |
| | | // CPageTransferLog æ¶æ¯å¤çç¨åº |
| | | |
| | | BOOL CPageGlassList::OnInitDialog() |
| | | { |
| | | CDialogEx::OnInitDialog(); |
| | | |
| | | // TODO: 卿¤æ·»å é¢å¤çåå§å |
| | | // 宿¶å¨ï¼1=åå§å订é
ï¼2=卿巿°ï¼åªå¢éï¼ |
| | | SetTimer(1, 3000, nullptr); |
| | | SetTimer(2, 2000, nullptr); |
| | | |
| | | // ä¸ææ¡æ§ä»¶ |
| | | InitStatusCombo(); |
| | |
| | | DWORD dwStyle = m_listCtrl.GetExtendedStyle(); |
| | | dwStyle |= LVS_EX_FULLROWSELECT; |
| | | dwStyle |= LVS_EX_GRIDLINES; |
| | | dwStyle |= LVS_EX_DOUBLEBUFFER; |
| | | m_listCtrl.SetExtendedStyle(dwStyle); |
| | | |
| | | HIMAGELIST imageList = ImageList_Create(24, 24, ILC_COLOR24, 1, 1); |
| | |
| | | |
| | | CString headers[] = { |
| | | _T(""), |
| | | _T("id"), |
| | | _T("Cassette Sequence No"), |
| | | _T("Job Sequence No"), |
| | | _T("Class ID"), |
| | |
| | | _T("è·¯å¾"), |
| | | _T("å·¥èºåæ°") |
| | | }; |
| | | int widths[] = { 0, 80, 80, 100, 120, 120, 120, 120, 200, 200, 200, 200 }; |
| | | int widths[] = { 24, 80, 80, 80, 100, 120, 120, 120, 120, 200, 200, 200, 200 }; |
| | | for (int i = 0; i < _countof(headers); ++i) { |
| | | strItem.Format(_T("Col_%d_Width"), i); |
| | | widths[i] = GetPrivateProfileInt("GlassListCtrl", strItem, widths[i], strIniFile); |
| | | m_listCtrl.InsertColumn(i, headers[i], LVCFMT_LEFT, widths[i]); |
| | | int def = widths[i]; |
| | | widths[i] = GetPrivateProfileInt("GlassListCtrl", strItem, def, strIniFile); |
| | | if (i == 0 && widths[i] < 16) widths[i] = 24; // 让ä¸è§å¾æ æç©ºé´å±ç¤º |
| | | m_listCtrl.InsertColumn(i, headers[i], i == 0 ? LVCFMT_RIGHT : LVCFMT_LEFT, widths[i]); |
| | | } |
| | | m_listCtrl.SetColumnWidth(10, LVSCW_AUTOSIZE_USEHEADER); |
| | | |
| | | |
| | | // è®¡ç®æ»é¡µæ° |
| | | /* |
| | | int nTotalRecords = TransferManager::getInstance().getTotalTransferCountAll(); |
| | | m_nTotalPages = (nTotalRecords + PAGE_SIZE - 1) / PAGE_SIZE; |
| | | m_nCurPage = 1; |
| | | */ |
| | | // äºæ¬¡å
åºï¼é²æ¢ ini åè¿äº 0 |
| | | if (m_listCtrl.GetColumnWidth(0) < 16) m_listCtrl.SetColumnWidth(0, 24); |
| | | |
| | | Resize(); |
| | | LoadTransfers(); |
| | | OnBnClickedButtonSearch(); // 触å䏿¬¡æ¥è¯¢ä¸é¦å±å¡«å
|
| | | |
| | | return TRUE; // return TRUE unless you set the focus to a control |
| | | // å¼å¸¸: OCX 屿§é¡µåºè¿å FALSE |
| | | } |
| | | |
| | | HBRUSH CPageGlassList::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor) |
| | |
| | | if (nCtlColor == CTLCOLOR_STATIC) { |
| | | pDC->SetBkColor(m_crBkgnd); |
| | | } |
| | | |
| | | if (m_hbrBkgnd == nullptr) { |
| | | m_hbrBkgnd = CreateSolidBrush(m_crBkgnd); |
| | | } |
| | | |
| | | return m_hbrBkgnd; |
| | | } |
| | | |
| | |
| | | m_pObserver = nullptr; |
| | | } |
| | | |
| | | // ä¿åå宽 |
| | | // ä¿åå宽ï¼é¦åå
åºï¼é¿å
æ 0 ååå»ï¼ |
| | | CString strIniFile, strItem, strTemp; |
| | | strIniFile.Format(_T("%s\\configuration.ini"), (LPTSTR)(LPCTSTR)theApp.m_strAppDir); |
| | | CHeaderCtrl* pHeader = m_listCtrl.GetHeaderCtrl(); |
| | | if (pHeader) { |
| | | for (int i = 0; i < pHeader->GetItemCount(); i++) { |
| | | RECT rect; |
| | | pHeader->GetItemRect(i, &rect); |
| | | strItem.Format(_T("Col_%d_Width"), i); |
| | | strTemp.Format(_T("%d"), rect.right - rect.left); |
| | | int w = rect.right - rect.left; |
| | | if (i == 0 && w < 16) w = 24; |
| | | strTemp.Format(_T("%d"), w); |
| | | WritePrivateProfileString("GlassListCtrl", strItem, strTemp, strIniFile); |
| | | } |
| | | } |
| | | } |
| | | |
| | |
| | | KillTimer(1); |
| | | InitRxWindow(); |
| | | } |
| | | else if (nIDEvent == 2) { |
| | | UpdateWipData(); // åªåå¢éï¼ä¸é建 |
| | | } |
| | | |
| | | CDialogEx::OnTimer(nIDEvent); |
| | | } |
| | | |
| | |
| | | int nCount = pComboBox->GetCount(); |
| | | m_dateTimeStart.EnableWindow(nIndex == nCount - 1); |
| | | m_dateTimeEnd.EnableWindow(nIndex == nCount - 1); |
| | | |
| | | // æ´æ°æ¥æè¿æ»¤å¨å页颿°æ® |
| | | UpdateDateFilter(); |
| | | LoadTransfers(); |
| | | } |
| | | |
| | | void CPageGlassList::OnCbnSelchangeComboStatusFilter() |
| | |
| | | pComboBox->GetLBText(nIndex, cstrText); |
| | | m_strStatus = CT2A(cstrText); |
| | | } |
| | | LoadTransfers(); |
| | | } |
| | | |
| | | void CPageGlassList::OnBnClickedButtonSearch() |
| | |
| | | // è·åå
³é®åè¾å
¥æ¡å
容 |
| | | CString strKeyword; |
| | | GetDlgItemText(IDC_EDIT_KEYWORD, strKeyword); |
| | | m_strKeyword = CT2A(strKeyword); |
| | | m_filters.keyword = CT2A(strKeyword); |
| | | |
| | | // æ´æ°æ¥æè¿æ»¤å¨å页颿°æ® |
| | | UpdateDateFilter(); |
| | | LoadTransfers(); |
| | | CComboBox* pComboBox = (CComboBox*)GetDlgItem(IDC_COMBO_DATETIME); |
| | | int index = pComboBox->GetCurSel(); |
| | | if (index == 0) { |
| | | // ä¸é |
| | | m_filters.tStartFrom = std::nullopt; |
| | | m_filters.tStartTo = std::nullopt; |
| | | } |
| | | else if (index == 1) { |
| | | auto [fromUtc, toUtc] = CToolUnits::CalcQuickRangeUtc(QuickRange::Today); |
| | | m_filters.tStartFrom = fromUtc; |
| | | m_filters.tStartTo = toUtc; |
| | | } |
| | | else if (index == 2) { |
| | | auto [fromUtc, toUtc] = CToolUnits::CalcQuickRangeUtc(QuickRange::Last7Days); |
| | | m_filters.tStartFrom = fromUtc; |
| | | m_filters.tStartTo = toUtc; |
| | | } |
| | | else if (index == 3) { |
| | | auto [fromUtc, toUtc] = CToolUnits::CalcQuickRangeUtc(QuickRange::ThisMonth); |
| | | m_filters.tStartFrom = fromUtc; |
| | | m_filters.tStartTo = toUtc; |
| | | } |
| | | else if (index == 4) { |
| | | auto [fromUtc, toUtc] = CToolUnits::CalcQuickRangeUtc(QuickRange::ThisYear); |
| | | m_filters.tStartFrom = fromUtc; |
| | | m_filters.tStartTo = toUtc; |
| | | } |
| | | else if (index == 5) { |
| | | // èªå®ä¹ |
| | | std::chrono::system_clock::time_point tp; |
| | | if (CToolUnits::GetCtrlDateRangeUtc_StartOfDay(m_dateTimeStart, tp)) m_filters.tStartFrom = tp; |
| | | if (CToolUnits::GetCtrlDateRangeUtc_EndOfDay(m_dateTimeEnd, tp)) m_filters.tStartTo = tp; |
| | | } |
| | | |
| | | #if USE_FAKE_DB_DEMO |
| | | long long total = _fake_total_count(); |
| | | #else |
| | | auto& db = GlassLogDb::Instance(); |
| | | long long total = db.count(m_filters); |
| | | #endif |
| | | m_nTotalPages = (PAGE_SIZE > 0) ? int((total + PAGE_SIZE - 1) / PAGE_SIZE) : 1; |
| | | |
| | | LoadData(); |
| | | } |
| | | |
| | | void CPageGlassList::OnBnClickedButtonExport() |
| | |
| | | return; |
| | | } |
| | | |
| | | CStdioFile file; |
| | | if (!file.Open(fileDialog.GetPathName(), CFile::modeCreate | CFile::modeWrite | CFile::typeText)) { |
| | | AfxMessageBox(_T("å建æä»¶å¤±è´¥ï¼")); |
| | | return; |
| | | // å¯¼åº CSVï¼å¯¼åºç¬¦å filters çâå
¨é¨è®°å½âï¼ä¸åå页éå¶ï¼ |
| | | auto& db = GlassLogDb::Instance(); |
| | | std::string csvPath((LPTSTR)(LPCTSTR)fileDialog.GetPathName()); |
| | | if (db.exportCsv(csvPath, m_filters) > 0) { |
| | | AfxMessageBox("导åºCSVæåï¼"); |
| | | } |
| | | |
| | | CString strHeader = _T("ä»»å¡ID,ç¶æ,ClassID,å建æ¶é´,åçæ¶é´,æ¾çæ¶é´,ç»ææ¶é´,æè¿°\n"); |
| | | file.WriteString(strHeader); |
| | | |
| | | for (int i = 0; i < m_listCtrl.GetItemCount(); ++i) { |
| | | CString row; |
| | | for (int j = 1; j <= 8; ++j) { |
| | | row += m_listCtrl.GetItemText(i, j); |
| | | if (j != 8) { |
| | | row += ","; |
| | | } |
| | | } |
| | | row += "\n"; |
| | | file.WriteString(row); |
| | | } |
| | | file.Close(); |
| | | } |
| | | |
| | | void CPageGlassList::OnBnClickedButtonPrevPage() |
| | | { |
| | | SERVO::CGlass g; |
| | | g.setID("GLS-001"); |
| | | g.setType(SERVO::MaterialsType::G1); |
| | | g.setOriginPort(1, 5); |
| | | g.setScheduledForProcessing(TRUE); |
| | | g.m_failReason = "none"; |
| | | g.markQueued(); |
| | | g.markStart(); |
| | | |
| | | |
| | | // æ·»å åæ° |
| | | CParam p1("æ ¡æ£å¯¹ä½å»¶æ¶", "P001", "ms", 123); |
| | | CParam p2("温度", "P002", "degC", 25.5); |
| | | g.getParams().push_back(p1); |
| | | g.getParams().push_back(p2); |
| | | |
| | | // 设置 JobDataS |
| | | SERVO::CJobDataS* js = g.getJobDataS(); |
| | | js->setCassetteSequenceNo(10); |
| | | js->setJobSequenceNo(20); |
| | | js->setLotId("LOT-ABC"); |
| | | js->setGlass1Id("GLS-001"); |
| | | |
| | | // æ·»å Path |
| | | g.addPath(100, 1); |
| | | SERVO::CPath* tail = g.getPath()->getTailPath(); |
| | | tail->setInTime(111111); |
| | | tail->setOutTime(222222); |
| | | tail->setInspResult(SERVO::InspResult::Pass); |
| | | tail->processEnd(); |
| | | return; |
| | | // 2. 转为 JSON |
| | | std::string jsonText = GlassJson::ToPrettyString(g); |
| | | TRACE("åºååç»æ:\n%s\n\n", jsonText.c_str()); |
| | | |
| | | // 3. ååºåå |
| | | SERVO::CGlass g2; |
| | | std::string err; |
| | | if (!GlassJson::FromString(jsonText, g2, &err)) { |
| | | TRACE("è§£æå¤±è´¥: %s\n", err.c_str()); |
| | | return; |
| | | } |
| | | |
| | | // 4. æå°éªè¯ |
| | | TRACE("ååºåååçID: %s\n", g2.getID().c_str()); |
| | | TRACE("ååºåååçåæ°æ°é: %d\n", (int)g2.getParams().size()); |
| | | if (!g2.getParams().empty()) { |
| | | TRACE("第ä¸ä¸ªåæ°å: %s å¼=%d\n", |
| | | g2.getParams()[0].getName().c_str(), |
| | | g2.getParams()[0].getIntValue()); |
| | | } |
| | | |
| | | |
| | | |
| | | if (m_nCurPage > 1) { |
| | | m_nCurPage--; |
| | | UpdatePageData(); |
| | | } |
| | | |
| | | } |
| | | |
| | | void CPageGlassList::OnBnClickedButtonNextPage() |
| | |
| | | UpdatePageData(); |
| | | } |
| | | } |
| | | |
| | | void CPageGlassList::UpdateWipData() |
| | | { |
| | | // åªå¨ç¬¬ 1 页巿° WIPï¼å
¶å®é¡µä¸å¨ |
| | | if (m_nCurPage != 1) return; |
| | | |
| | | const int colCount = m_listCtrl.GetHeaderCtrl() ? m_listCtrl.GetHeaderCtrl()->GetItemCount() : 0; |
| | | if (colCount <= 0) return; |
| | | |
| | | // 1) æ¶éå½åå¯è§éçâWIP è¡âï¼ç¬¬1å id ä¸ºç©ºï¼ |
| | | // a) wipRowByIdï¼classId -> (row, node*)ï¼æ¶éâæ ¹+åâçå
¨é¨ï¼ä¾¿äºå¤æâbuddy æ¯å¦å·²å¨å¯è§è¡¨ä¸â |
| | | // b) wipRootByIdï¼classId -> node*ï¼ä»
æ¶éâæ ¹èç¹âï¼ä¾¿äºåªå¯¹æ ¹èç¹è¡¥å项 |
| | | std::unordered_map<std::string, std::pair<int, CExpandableListCtrl::Node*>> wipRowById; |
| | | std::unordered_map<std::string, CExpandableListCtrl::Node*> wipRootById; |
| | | for (int row = 0; row < m_listCtrl.GetItemCount(); ++row) { |
| | | CString idDb = m_listCtrl.GetItemText(row, 1); // 第1忝 DB id |
| | | if (!idDb.IsEmpty()) continue; // æ id çæ¯ DB è¡ï¼è·³è¿ |
| | | |
| | | auto* node = m_listCtrl.GetNodeByVisibleIndex(row); |
| | | CString cls = m_listCtrl.GetItemText(row, 4); // 第4å Class ID |
| | | #ifdef _UNICODE |
| | | std::string key = CT2A(cls); |
| | | #else |
| | | std::string key = cls.GetString(); |
| | | #endif |
| | | wipRowById[key] = { row, node }; |
| | | if (node && node->parent == nullptr) { |
| | | wipRootById[key] = node; // ä»
æ ¹èç¹è¿å
¥è¿ä¸ªè¡¨ |
| | | } |
| | | } |
| | | |
| | | // 2) æå½å WIP å表 |
| | | std::vector<SERVO::CGlass*> wipGlasses; |
| | | theApp.m_model.m_master.getWipGlasses(wipGlasses); |
| | | std::vector<SERVO::CGlass*> tempRetain = wipGlasses; // ç¨åç»ä¸ release |
| | | /* |
| | | static int i = 0; |
| | | i++; |
| | | if (i == 8) { |
| | | for (auto item : wipGlasses) { |
| | | if (item->getBuddy() != nullptr) { |
| | | item->setInspResult(EQ_ID_MEASUREMENT, 0, SERVO::InspResult::Fail); |
| | | item->getBuddy()->setID("11111"); |
| | | } |
| | | } |
| | | } |
| | | if (i == 16) { |
| | | for (auto item : wipGlasses) { |
| | | if (item->getBuddy() != nullptr) { |
| | | item->setInspResult(EQ_ID_MEASUREMENT, 0, SERVO::InspResult::Pass); |
| | | item->getBuddy()->setID("22222"); |
| | | } |
| | | } |
| | | } |
| | | */ |
| | | auto makeColsFromWip = [&](SERVO::CGlass* g) { |
| | | std::vector<CString> cols(colCount); |
| | | cols[1] = _T(""); // WIP 没 DB id |
| | | cols[2] = std::to_string(g->getCassetteSequenceNo()).c_str(); |
| | | cols[3] = std::to_string(g->getJobSequenceNo()).c_str(); |
| | | cols[4] = g->getID().c_str(); |
| | | cols[5] = SERVO::CServoUtilsTool::getMaterialsTypeText(g->getType()).c_str(); |
| | | cols[6] = SERVO::CServoUtilsTool::getGlassStateText(g->state()).c_str(); |
| | | cols[7] = CToolUnits::TimePointToLocalString(g->tStart()).c_str(); |
| | | cols[8] = CToolUnits::TimePointToLocalString(g->tEnd()).c_str(); |
| | | cols[9] = g->getBuddyId().c_str(); |
| | | cols[10] = SERVO::CServoUtilsTool::getInspResultText((SERVO::InspResult)g->getAOIInspResult()).c_str(); |
| | | cols[11] = g->getPathDescription().c_str(); |
| | | cols[12] = g->getParamsDescription().c_str(); |
| | | return cols; |
| | | }; |
| | | |
| | | bool needRebuildChildren = false; // æ¬æ¬¡æ¯å¦æ°å¢äºåèç¹ï¼ç»æååï¼ |
| | | bool needRebuildAllForNewRoot = false;// æ¬æ¬¡æ¯å¦åç°äºâæ°å¢æ ¹èç¹âçéæ±ï¼ä¸ºä¿è¯ WIP å¨é¡¶é¨ï¼ |
| | | std::vector<int> rowsToRedraw; // ä»
ææ¬ååçè¡ |
| | | |
| | | // UI ç¶æï¼å½éè¦é建æ¶ä½¿ç¨ï¼ |
| | | std::vector<CExpandableListCtrl::Node*> savedSel; |
| | | CExpandableListCtrl::Node* savedTop = nullptr; |
| | | |
| | | // 3) é个å¤ç WIPï¼å·²åå¨ -> 就尿´æ°ï¼å¿
è¦æ¶âåªå¯¹æ ¹è¡¥å项â |
| | | // ä¸åå¨ -> 触åâå
¨éé建âï¼ä»¥ä¿è¯æ° WIP æ ¹è¡åºç°å¨åè¡¨é¡¶é¨ |
| | | for (auto* g : wipGlasses) { |
| | | if (!GlassMatchesFilters(*g, m_filters)) continue; |
| | | |
| | | #ifdef _UNICODE |
| | | std::string cid = CT2A(g->getID().c_str()); |
| | | #else |
| | | std::string cid = g->getID(); |
| | | #endif |
| | | |
| | | auto itAny = wipRowById.find(cid); |
| | | if (itAny != wipRowById.end()) { |
| | | // (A) å·²åå¨ï¼ä»
æ´æ°ææ¡ & éç»è¯¥è¡ |
| | | int row = itAny->second.first; |
| | | m_listCtrl.SetItemText(row, 2, std::to_string(g->getCassetteSequenceNo()).c_str()); |
| | | m_listCtrl.SetItemText(row, 3, std::to_string(g->getJobSequenceNo()).c_str()); |
| | | m_listCtrl.SetItemText(row, 4, g->getID().c_str()); |
| | | m_listCtrl.SetItemText(row, 5, SERVO::CServoUtilsTool::getMaterialsTypeText(g->getType()).c_str()); |
| | | m_listCtrl.SetItemText(row, 6, SERVO::CServoUtilsTool::getGlassStateText(g->state()).c_str()); |
| | | m_listCtrl.SetItemText(row, 7, CToolUnits::TimePointToLocalString(g->tStart()).c_str()); |
| | | m_listCtrl.SetItemText(row, 8, CToolUnits::TimePointToLocalString(g->tEnd()).c_str()); |
| | | m_listCtrl.SetItemText(row, 9, g->getBuddyId().c_str()); |
| | | m_listCtrl.SetItemText(row, 10, SERVO::CServoUtilsTool::getInspResultText((SERVO::InspResult)g->getAOIInspResult()).c_str()); |
| | | m_listCtrl.SetItemText(row, 11, g->getPathDescription().c_str()); |
| | | m_listCtrl.SetItemText(row, 12, g->getParamsDescription().c_str()); |
| | | rowsToRedraw.push_back(row); |
| | | |
| | | // ââ é¡ºå¸¦å·æ° buddy åè¡ï¼å¦æå®å·²å¨å¯è§è¡¨éï¼ââ |
| | | if (SERVO::CGlass* b = g->getBuddy()) { |
| | | CString buddyCidCs = b->getID().c_str(); |
| | | #ifdef _UNICODE |
| | | std::string bid = CT2A(buddyCidCs); |
| | | #else |
| | | std::string bid = buddyCidCs.GetString(); |
| | | #endif |
| | | auto itChildAny = wipRowById.find(bid); |
| | | if (itChildAny != wipRowById.end()) { |
| | | int crow = itChildAny->second.first; |
| | | // çæ buddy çåææ¬å¹¶ä¸æ¬¡æ§åå |
| | | auto bcols = makeColsFromWip(b); |
| | | ApplyColsToRow(m_listCtrl, crow, bcols); |
| | | rowsToRedraw.push_back(crow); |
| | | } |
| | | // 妿 buddy è¡å½åä¸åå¨ï¼å¯ä¿çä½ åæ¥çâåªå¨æ ¹ä¸ãä¸ buddy ä¸å¨å¯è§è¡¨æ¶è¡¥å项âçé»è¾ |
| | | } |
| | | |
| | | // ââ åªå¯¹âæ ¹èç¹âè¡¥å项ï¼ä¸ä»
å½ buddy å°æªåºç°å¨å¯è§è¡¨ï¼ä¸æ ¹ä¸ä¹æ²¡æè¯¥ buddy ââ |
| | | SERVO::CGlass* b = g->getBuddy(); |
| | | if (b) { |
| | | // å½åæ ¹å®¹å¨ï¼ï¼åèç¹ä¸ä½ä¸ºå®¹å¨ï¼ |
| | | auto itRoot = wipRootById.find(cid); |
| | | if (itRoot != wipRootById.end()) { |
| | | CExpandableListCtrl::Node* container = itRoot->second; |
| | | |
| | | CString newBuddyCid = b->getID().c_str(); |
| | | #ifdef _UNICODE |
| | | std::string newBid = CT2A(newBuddyCid); |
| | | #else |
| | | std::string newBid = newBuddyCid.GetString(); |
| | | #endif |
| | | |
| | | // ç°æå®¹å¨ä¸çâ第ä¸ä¸ªå classIdâï¼å¦ææçè¯ï¼ |
| | | CString oldChildCid; |
| | | if (!container->children.empty() && container->children[0] && container->children[0]->cols.size() > 4) |
| | | oldChildCid = container->children[0]->cols[4]; |
| | | |
| | | bool buddyExistsAnywhere = (wipRowById.find(newBid) != wipRowById.end()); |
| | | bool hasChildAlready = NodeHasChildWithClassId(container, newBuddyCid); |
| | | |
| | | // ââ å
³é®ï¼å
³ç³»æ¯å¦åçååï¼ï¼oldChildCid ä¸ newBuddyCid ä¸åï¼ |
| | | bool relationChanged = |
| | | (!oldChildCid.IsEmpty() && newBuddyCid.IsEmpty()) || // ä¹åæåï¼ç°å¨æ²¡ buddy |
| | | (oldChildCid.IsEmpty() && !newBuddyCid.IsEmpty()) || // ä¹å没åï¼ç°å¨æ buddy |
| | | (!oldChildCid.IsEmpty() && !newBuddyCid.IsEmpty() && oldChildCid.CompareNoCase(newBuddyCid) != 0); // æ¹ buddy |
| | | |
| | | if (relationChanged) { |
| | | // å
³ç³»åæ´èµ°âç»æé建âï¼é¿å
é夿ååæè½½ |
| | | needRebuildAllForNewRoot = true; |
| | | } |
| | | else { |
| | | // å
³ç³»æªåï¼è¥ buddy è¿ä¸å¨å¯è§è¡¨ä¸å®¹å¨ä¸ä¹æ²¡æï¼åè¡¥å |
| | | if (!buddyExistsAnywhere && !hasChildAlready) { |
| | | if (!needRebuildChildren) { CaptureUiState(m_listCtrl, savedSel, savedTop); } |
| | | needRebuildChildren = true; |
| | | auto cols = makeColsFromWip(b); |
| | | auto* ch = m_listCtrl.InsertChild(container, cols); |
| | | m_listCtrl.SetNodeColor(ch, kWipText, kWipChildBk); // åï¼æ´æµ
|
| | | m_listCtrl.SetNodeColor(container, kWipText, kWipParentBk); // ç¶ï¼åºç¡ç»¿ï¼å
åºçº æ£ï¼ |
| | | } |
| | | // è¥å·²æåï¼é¡ºå¸¦æåè¡ææ¬å·æ°ä¸ä¸ï¼æ¯å¦ AOI æ´æ°ï¼ |
| | | else if (hasChildAlready) { |
| | | // æ¾å°å¯¹åºåå¹¶æ´æ°ææ¬/colsï¼é¿å
åç» Rebuild ååæ§å¼ |
| | | for (auto& ch : container->children) { |
| | | if (ch && ch->cols.size() > 4 && ch->cols[4].CompareNoCase(newBuddyCid) == 0) { |
| | | auto cols = makeColsFromWip(b); |
| | | ch->cols = cols; // åºå±æ°æ® |
| | | // å¯è§è¡å·æ° |
| | | for (int r = 0; r < m_listCtrl.GetItemCount(); ++r) { |
| | | if (m_listCtrl.GetNodeByVisibleIndex(r) == ch.get()) { |
| | | for (int c = 1; c < (int)cols.size(); ++c) { |
| | | m_listCtrl.SetItemText(r, c, cols[c]); |
| | | m_listCtrl.SetNodeColor(ch.get(), kWipText, kWipChildBk); // ä¿è¯åè¡æ¯æµ
è² |
| | | m_listCtrl.SetNodeColor(container, kWipText, kWipParentBk); // ç¶ä¿æåºç¡ç»¿ |
| | | } |
| | | rowsToRedraw.push_back(r); |
| | | break; |
| | | } |
| | | } |
| | | break; |
| | | } |
| | | } |
| | | } |
| | | } |
| | | } |
| | | // å½åæ¯âåèç¹âçæ
åµï¼ä¸å¾ä¸æåï¼äº¤ç»é建ï¼è¥ç¶åæ´ï¼ |
| | | } |
| | | else { |
| | | // 没æ buddyï¼å¦æå®¹å¨ä¸ç°å¨æåï¼ä¹ç®å
³ç³»ååï¼è§¦åé建 |
| | | auto itRoot = wipRootById.find(cid); |
| | | if (itRoot != wipRootById.end()) { |
| | | CExpandableListCtrl::Node* container = itRoot->second; |
| | | if (!container->children.empty()) |
| | | needRebuildAllForNewRoot = true; |
| | | } |
| | | } |
| | | } |
| | | else { |
| | | // (B) ä¸åå¨ï¼æ°å¢æ ¹è¡ââ为ä¿è¯âWIP æ°¸è¿å¨é¡¶é¨âï¼è§¦åå
¨éé建 |
| | | needRebuildAllForNewRoot = true; |
| | | } |
| | | } |
| | | |
| | | // 4) åºç¨ UI æ´æ° |
| | | if (needRebuildAllForNewRoot) { |
| | | // ç¨ keyï¼ClassIDï¼ä¿åå¹¶æ¢å¤ï¼é¿å
Node* 失æ |
| | | auto selKeys = SnapshotSelectedKeys(m_listCtrl); |
| | | auto topKey = SnapshotTopKey(m_listCtrl); |
| | | UpdatePageData(); // å
¨éé建ï¼WIP é¡¶é¨ï¼ |
| | | RestoreSelectionByKeys(m_listCtrl, selKeys); |
| | | RestoreTopByKey(m_listCtrl, topKey); |
| | | } |
| | | else if (needRebuildChildren) { |
| | | auto selKeys = SnapshotSelectedKeys(m_listCtrl); |
| | | auto topKey = SnapshotTopKey(m_listCtrl); |
| | | m_listCtrl.RebuildVisible(); // ä»
ç»æååï¼å åï¼ |
| | | RestoreSelectionByKeys(m_listCtrl, selKeys); |
| | | RestoreTopByKey(m_listCtrl, topKey); |
| | | } |
| | | else { |
| | | for (int row : rowsToRedraw) // ä»
ææ¬åå |
| | | m_listCtrl.RedrawItems(row, row); |
| | | } |
| | | |
| | | // 5) éæ¾ retain |
| | | for (auto* g : tempRetain) g->release(); |
| | | } |
| | | |
| | | void CPageGlassList::InsertWipRow(SERVO::CGlass* /*pGlass*/) |
| | | { |
| | | // ä¸åä½¿ç¨ |
| | | } |
| | | |
| | | void CPageGlassList::UpdateWipRow(unsigned int /*index*/, SERVO::CGlass* /*pGlass*/) |
| | | { |
| | | // ä¸åä½¿ç¨ |
| | | } |
| | | |
| | | bool CPageGlassList::eraseGlassInVector(SERVO::CGlass* /*pGlass*/, std::vector<SERVO::CGlass*>& /*glasses*/) |
| | | { |
| | | return false; |
| | | } |
| | | |
| | | // ===== è¿æ»¤é»è¾ï¼åæ ·ä¿çï¼ ===== |
| | | |
| | | // æ ¸å¿ï¼WIP ç CGlass æ¯å¦å½ä¸å½å Filters |
| | | // useEndTime=true æ¶ç¨ tEnd 夿¶é´ï¼æ¯å¦â宿å表âç¨ t_endï¼ï¼é»è®¤æ tStartã |
| | | bool CPageGlassList::GlassMatchesFilters(const SERVO::CGlass& g, |
| | | const GlassLogDb::Filters& f, |
| | | bool useEndTime/* = false*/) |
| | | { |
| | | // 1) ç²¾ç¡®åæ®µ |
| | | if (f.classId && g.getID() != *f.classId) return false; |
| | | if (f.cassetteSeqNo && g.getCassetteSequenceNo() != *f.cassetteSeqNo) return false; |
| | | if (f.jobSeqNo && g.getJobSequenceNo() != *f.jobSeqNo) return false; |
| | | |
| | | // 2) å
³é®åï¼ä¸ DB ä¿æä¸è´ï¼class_id / buddy_id / path / params / prettyï¼ |
| | | if (f.keyword) { |
| | | const std::string& kw = *f.keyword; |
| | | if (!(CToolUnits::containsCI(g.getID(), kw) |
| | | || CToolUnits::containsCI(g.getBuddyId(), kw) |
| | | || CToolUnits::containsCI(g.getPathDescription(), kw) |
| | | || CToolUnits::containsCI(g.getParamsDescription(), kw))) |
| | | return false; |
| | | } |
| | | |
| | | // 3) æ¶é´ï¼ä¸ DB ä¿æä¸è´ï¼é»è®¤æ t_start è¿æ»¤ï¼éè¦å¯åå° t_endï¼ |
| | | if (f.tStartFrom || f.tStartTo) { |
| | | std::optional<std::chrono::system_clock::time_point> tp = useEndTime ? g.tEnd() : g.tStart(); |
| | | // 约å®ï¼è¥æ²¡æå¯¹åºæ¶é´æ³ï¼åè§ä¸ºä¸å½ä¸ï¼ä¸ DB ç¸åï¼NULL ä¸ä¼å½ä¸èå´ï¼ |
| | | if (!tp) return false; |
| | | if (f.tStartFrom && *tp < *f.tStartFrom) return false; |
| | | if (f.tStartTo && *tp > *f.tStartTo) return false; |
| | | } |
| | | |
| | | return true; |
| | | } |
| | |
| | | #pragma once |
| | | #include "ListCtrlEx.h" |
| | | #include "CExpandableListCtrl.h" |
| | | #include "GlassLogDb.h" |
| | | |
| | | |
| | | // CPageGlassList å¯¹è¯æ¡ |
| | |
| | | IObserver* m_pObserver; |
| | | |
| | | // æç´¢å
³é®å |
| | | GlassLogDb::Filters m_filters; |
| | | std::string m_strStatus; |
| | | std::string m_strKeyword; |
| | | |
| | | // 页ç |
| | | int m_nCurPage; |
| | |
| | | // æ§ä»¶ |
| | | CDateTimeCtrl m_dateTimeStart; |
| | | CDateTimeCtrl m_dateTimeEnd; |
| | | CListCtrlEx m_listCtrl; |
| | | CExpandableListCtrl m_listCtrl; |
| | | |
| | | private: |
| | | int m_nColCount = 0; |
| | | bool m_rebuilding = false; |
| | | |
| | | private: |
| | | void InitRxWindow(); |
| | |
| | | void InitStatusCombo(); |
| | | void InitTimeRangeCombo(); |
| | | void InitDateTimeControls(); |
| | | void LoadTransfers(); |
| | | void LoadData(); |
| | | void UpdatePageData(); |
| | | void UpdatePageControls(); |
| | | void UpdateDateFilter(); |
| | | /* |
| | | void FillDataToListCtrl(const std::vector<TransferData>& vecData); |
| | | void InsertTransferData(const TransferData& data); |
| | | */ |
| | | void InsertWipRow(SERVO::CGlass* pGlass); |
| | | static bool GlassMatchesFilters(const SERVO::CGlass& g, |
| | | const GlassLogDb::Filters& f, |
| | | bool useEndTime = false); |
| | | void UpdateWipData(); |
| | | bool eraseGlassInVector(SERVO::CGlass* pGlass, std::vector<SERVO::CGlass*>& glasses); |
| | | void UpdateWipRow(unsigned int index, SERVO::CGlass* pGlass); |
| | | |
| | | // å¯¹è¯æ¡æ°æ® |
| | | #ifdef AFX_DESIGN_TIME |
| | |
| | | #include "stdafx.h" |
| | | #include "CPath.h" |
| | | #include "ToolUnits.h" |
| | | #include "CServoUtilsTool.h" |
| | | |
| | | |
| | | namespace SERVO { |
| | |
| | | m_pNext = nullptr; |
| | | } |
| | | |
| | | CPath::CPath(unsigned int nEqId, unsigned int nUnit) |
| | | CPath::CPath(unsigned int nEqId, unsigned int nUnit, unsigned int nSlot) |
| | | { |
| | | m_nEqID = nEqId; |
| | | m_nUnit = nUnit; |
| | | m_nSlot = nSlot; |
| | | m_timeOut = 0; |
| | | m_timeIn = CToolUnits::getTimestamp(); |
| | | m_bProcessed = FALSE; |
| | |
| | | strOut = strOut + ">"; |
| | | } |
| | | |
| | | void CPath::getSimpleDescription(std::string& strOut) |
| | | { |
| | | strOut = CServoUtilsTool::getEqUnitName(m_nEqID, m_nUnit, m_nSlot); |
| | | } |
| | | |
| | | void CPath::serialize(CArchive& ar) |
| | | { |
| | | if (ar.IsStoring()) { |
| | | ar << m_nEqID; |
| | | ar << m_nUnit; |
| | | ar << m_nSlot; |
| | | ar << m_timeIn; |
| | | ar << m_timeOut; |
| | | ar << m_bProcessed; |
| | |
| | | |
| | | ar >> m_nEqID; |
| | | ar >> m_nUnit; |
| | | ar >> m_nSlot; |
| | | ar >> m_timeIn; |
| | | ar >> m_timeOut; |
| | | ar >> m_bProcessed; |
| | |
| | | return m_nUnit; |
| | | } |
| | | |
| | | unsigned int CPath::getSlot() |
| | | { |
| | | return m_nSlot; |
| | | } |
| | | |
| | | void CPath::setInTime(ULONGLONG time) |
| | | { |
| | | m_timeIn = time; |
| | |
| | | { |
| | | public: |
| | | CPath(); |
| | | CPath(unsigned int nEqId, unsigned int nUnit); |
| | | CPath(unsigned int nEqId, unsigned int nUnit, unsigned int nSlot); |
| | | virtual ~CPath(); |
| | | |
| | | public: |
| | | void getDescription(std::string& strOut); |
| | | void getSimpleDescription(std::string& strOut); |
| | | void serialize(CArchive& ar); |
| | | CPath* getPrev(); |
| | | CPath* getNext(); |
| | |
| | | CPath* getHeadPath(); |
| | | unsigned int getEqID(); |
| | | unsigned int getUnit(); |
| | | unsigned int getSlot(); |
| | | void setInTime(ULONGLONG time); |
| | | ULONGLONG getInTime(); |
| | | void setOutTime(ULONGLONG time); |
| | |
| | | private: |
| | | unsigned int m_nEqID; |
| | | unsigned int m_nUnit; |
| | | unsigned int m_nSlot; |
| | | ULONGLONG m_timeIn; |
| | | ULONGLONG m_timeOut; |
| | | BOOL m_bProcessed; |
| | |
| | | LOGI(_T("RobotTaskå·²ä¸åå°EFEM")); |
| | | } |
| | | else { |
| | | LOGI(_T("RobotTaskä¸å失败")); |
| | | LOGE(_T("RobotTaskä¸å失败")); |
| | | } |
| | | |
| | | return 0; |
| | |
| | | LOGI(_T("RobotTask/getå·²ä¸åå°EFEM")); |
| | | } |
| | | else { |
| | | LOGI(_T("RobotTask/getå·²ä¸å失败")); |
| | | LOGE(_T("RobotTask/getå·²ä¸å失败")); |
| | | } |
| | | |
| | | return 0; |
| | |
| | | LOGI(_T("RobotTask/putå·²ä¸åå°EFEM")); |
| | | } |
| | | else { |
| | | LOGI(_T("RobotTask/putå·²ä¸å失败")); |
| | | LOGE(_T("RobotTask/putå·²ä¸å失败")); |
| | | } |
| | | |
| | | return 0; |
| | |
| | | LOGI(_T("RobotTask/restore-putå·²ä¸åå°EFEM")); |
| | | } |
| | | else { |
| | | LOGI(_T("RobotTask/restore-putå·²ä¸å失败")); |
| | | LOGE(_T("RobotTask/restore-putå·²ä¸å失败")); |
| | | } |
| | | |
| | | return 0; |
| ¶Ô±ÈÐÂÎļþ |
| | |
| | | #include "stdafx.h" |
| | | #include "CSVData.h" |
| | | #include "ToolUnits.h" |
| | | |
| | | |
| | | namespace SERVO { |
| | | CSVData::CSVData() |
| | | { |
| | | |
| | | } |
| | | |
| | | CSVData::~CSVData() |
| | | { |
| | | |
| | | } |
| | | |
| | | std::string& CSVData::getTime() |
| | | { |
| | | return m_strTime; |
| | | } |
| | | |
| | | std::vector<uint8_t>& CSVData::getSVRawData() |
| | | { |
| | | return m_svRawData; |
| | | } |
| | | |
| | | int CSVData::serialize(char* pszBuffer, int nBufferSize) |
| | | { |
| | | if (nBufferSize < 133) return -1; |
| | | |
| | | int index = 0; |
| | | CToolUnits::convertString(&pszBuffer[index], 8, m_strTime); |
| | | index += 8; |
| | | |
| | | memcpy(&pszBuffer[index], m_svRawData.data(), 125); |
| | | index += 125; |
| | | |
| | | return 133; |
| | | } |
| | | |
| | | int CSVData::unserialize(const char* pszBuffer, int nBufferSize) |
| | | { |
| | | if (nBufferSize < 133) return -1; |
| | | |
| | | int index = 0; |
| | | CSVData svData; |
| | | CToolUnits::convertString(&pszBuffer[index], 8 * 2, m_strTime); |
| | | index += 8 * 2; |
| | | |
| | | m_svRawData.clear(); |
| | | m_svRawData.insert(m_svRawData.end(), (uint8_t*)(&pszBuffer[index]), (uint8_t*)(pszBuffer)+(125 * 2)); |
| | | index += 125 * 2; |
| | | |
| | | return 133; |
| | | } |
| | | } |
| ¶Ô±ÈÐÂÎļþ |
| | |
| | | #pragma once |
| | | |
| | | |
| | | namespace SERVO { |
| | | class CSVData |
| | | { |
| | | public: |
| | | CSVData(); |
| | | virtual ~CSVData(); |
| | | |
| | | public: |
| | | std::string& getTime(); |
| | | std::vector<uint8_t>& getSVRawData(); |
| | | int serialize(char* pszBuffer, int nBufferSize); |
| | | int unserialize(const char* pszBuffer, int nBufferSize); |
| | | |
| | | private: |
| | | std::string m_strTime; |
| | | std::vector<uint8_t> m_svRawData; |
| | | }; |
| | | } |
| | | |
| ¶Ô±ÈÐÂÎļþ |
| | |
| | | #include "stdafx.h" |
| | | #include "CServoUtilsTool.h" |
| | | #include "Common.h" |
| | | |
| | | |
| | | namespace SERVO { |
| | | CServoUtilsTool::CServoUtilsTool() |
| | | { |
| | | |
| | | } |
| | | |
| | | CServoUtilsTool::~CServoUtilsTool() |
| | | { |
| | | |
| | | } |
| | | |
| | | std::string CServoUtilsTool::getEqUnitName(int eqid, int unit) |
| | | { |
| | | char szBuffer[256]; |
| | | if (eqid == EQ_ID_LOADPORT1 |
| | | || eqid == EQ_ID_LOADPORT2 |
| | | || eqid == EQ_ID_LOADPORT3 |
| | | || eqid == EQ_ID_LOADPORT4 |
| | | ) { |
| | | sprintf_s(szBuffer, 256, "Port%d(Slot%d)", eqid - EQ_ID_LOADPORT1 + 1, unit + 1); |
| | | return std::string(szBuffer); |
| | | } |
| | | |
| | | if (eqid == EQ_ID_ALIGNER) { |
| | | return "Aligner"; |
| | | } |
| | | |
| | | if (eqid == EQ_ID_FLIPER) { |
| | | return "Fliper"; |
| | | } |
| | | |
| | | if (eqid == EQ_ID_VACUUMBAKE) { |
| | | if (unit == 0) return "çç¤Aè
"; |
| | | if (unit == 1) return "çç¤Bè
"; |
| | | } |
| | | |
| | | if (eqid == EQ_ID_VACUUMBAKE) { |
| | | if (unit == 0) return "çç¤Aè
"; |
| | | if (unit == 1) return "çç¤Bè
"; |
| | | } |
| | | |
| | | if (eqid == EQ_ID_Bonder1) { |
| | | return "Bonder1"; |
| | | } |
| | | |
| | | if (eqid == EQ_ID_Bonder2) { |
| | | return "Bonder2"; |
| | | } |
| | | |
| | | if (eqid == EQ_ID_BAKE_COOLING) { |
| | | |
| | | if (unit == 0) return "åçç¤Aè
"; |
| | | if (unit == 1) return "å·å´A"; |
| | | if (unit == 0) return "åçç¤Bè
"; |
| | | if (unit == 1) return "å·å´B"; |
| | | } |
| | | |
| | | if (eqid == EQ_ID_MEASUREMENT) { |
| | | return "AOI"; |
| | | } |
| | | |
| | | |
| | | if (eqid == EQ_ID_ARM_TRAY1) { |
| | | return "ARM1"; |
| | | } |
| | | |
| | | if (eqid == EQ_ID_ARM_TRAY2) { |
| | | return "ARM2"; |
| | | } |
| | | |
| | | return ""; |
| | | } |
| | | |
| | | std::string CServoUtilsTool::getEqUnitName(int eqid, int unit, int slot) |
| | | { |
| | | char szBuffer[256]; |
| | | if (eqid == EQ_ID_LOADPORT1 |
| | | || eqid == EQ_ID_LOADPORT2 |
| | | || eqid == EQ_ID_LOADPORT3 |
| | | || eqid == EQ_ID_LOADPORT4 |
| | | ) { |
| | | sprintf_s(szBuffer, 256, "Port%d(Slot%d)", eqid - EQ_ID_LOADPORT1 + 1, slot); |
| | | return std::string(szBuffer); |
| | | } |
| | | |
| | | if (eqid == EQ_ID_ALIGNER) { |
| | | return "Aligner"; |
| | | } |
| | | |
| | | if (eqid == EQ_ID_FLIPER) { |
| | | return "Fliper"; |
| | | } |
| | | |
| | | if (eqid == EQ_ID_VACUUMBAKE) { |
| | | if (unit == 0) { |
| | | sprintf_s(szBuffer, 256, "çç¤Aè
(Slot%d)", slot); |
| | | return std::string(szBuffer); |
| | | } |
| | | if (unit == 1) { |
| | | sprintf_s(szBuffer, 256, "çç¤Bè
(Slot%d)", slot); |
| | | return std::string(szBuffer); |
| | | } |
| | | } |
| | | |
| | | if (eqid == EQ_ID_Bonder1) { |
| | | sprintf_s(szBuffer, 256, "Bonder1(Slot%d)", slot); |
| | | return std::string(szBuffer); |
| | | } |
| | | |
| | | if (eqid == EQ_ID_Bonder2) { |
| | | sprintf_s(szBuffer, 256, "Bonder2(Slot%d)", slot); |
| | | return std::string(szBuffer); |
| | | } |
| | | |
| | | if (eqid == EQ_ID_BAKE_COOLING) { |
| | | |
| | | if (slot == 0) return "åçç¤Aè
"; |
| | | if (slot == 1) return "å·å´A"; |
| | | if (slot == 0) return "åçç¤Bè
"; |
| | | if (slot == 1) return "å·å´B"; |
| | | } |
| | | |
| | | if (eqid == EQ_ID_MEASUREMENT) { |
| | | return "AOI"; |
| | | } |
| | | |
| | | |
| | | if (eqid == EQ_ID_ARM_TRAY1) { |
| | | return "ARM1"; |
| | | } |
| | | |
| | | if (eqid == EQ_ID_ARM_TRAY2) { |
| | | return "ARM2"; |
| | | } |
| | | |
| | | return ""; |
| | | } |
| | | |
| | | std::string CServoUtilsTool::getMaterialsTypeText(MaterialsType type) |
| | | { |
| | | if (type == MaterialsType::G1) { |
| | | return "G1"; |
| | | } |
| | | |
| | | if (type == MaterialsType::G2) { |
| | | return "G2"; |
| | | } |
| | | |
| | | return ""; |
| | | } |
| | | |
| | | std::string CServoUtilsTool::getGlassStateText(SERVO::GlsState state) |
| | | { |
| | | switch (state) |
| | | { |
| | | case SERVO::GlsState::NoState: |
| | | return "NoState"; |
| | | break; |
| | | case SERVO::GlsState::Queued: |
| | | return "Queued"; |
| | | break; |
| | | case SERVO::GlsState::InProcess: |
| | | return "InProcess"; |
| | | break; |
| | | case SERVO::GlsState::Paused: |
| | | return "Paused"; |
| | | break; |
| | | case SERVO::GlsState::Completed: |
| | | return "Completed"; |
| | | break; |
| | | case SERVO::GlsState::Aborted: |
| | | return "Aborted"; |
| | | break; |
| | | case SERVO::GlsState::Failed: |
| | | return "Failed"; |
| | | break; |
| | | default: |
| | | return ""; |
| | | break; |
| | | } |
| | | } |
| | | |
| | | std::string CServoUtilsTool::getInspResultText(SERVO::InspResult result) |
| | | { |
| | | switch (result) |
| | | { |
| | | case SERVO::InspResult::NotInspected: |
| | | return ""; |
| | | break; |
| | | case SERVO::InspResult::Pass: |
| | | return "Pass"; |
| | | break; |
| | | case SERVO::InspResult::Fail: |
| | | return "Fail"; |
| | | break; |
| | | default: |
| | | return ""; |
| | | break; |
| | | } |
| | | } |
| | | } |
| ¶Ô±ÈÐÂÎļþ |
| | |
| | | #pragma once |
| | | #include "ServoCommo.h" |
| | | #include "CGlass.h" |
| | | |
| | | |
| | | namespace SERVO { |
| | | class CServoUtilsTool |
| | | { |
| | | public: |
| | | CServoUtilsTool(); |
| | | virtual ~CServoUtilsTool(); |
| | | |
| | | public: |
| | | static std::string getEqUnitName(int eqid, int unit); |
| | | static std::string getEqUnitName(int eqid, int unit, int slot); |
| | | static std::string getMaterialsTypeText(MaterialsType type); |
| | | static std::string getGlassStateText(SERVO::GlsState state); |
| | | static std::string getInspResultText(SERVO::InspResult result); |
| | | }; |
| | | } |
| | | |
| | |
| | | } |
| | | } |
| | | |
| | | // FAC Data Report |
| | | addFacDataReportStep(0x16589, 0xc4d, 1); |
| | | /* |
| | | { |
| | | CEqReadStep* pStep = new CEqReadStep(0x16589, 133 * 2, |
| | | [&](void* pFrom, int code, const char* pszData, size_t size) -> int { |
| | | if (code == ROK && pszData != nullptr && size > 0) { |
| | | decodeFacDataReport((CStep*)pFrom, pszData, size); |
| | | } |
| | | return -1; |
| | | }); |
| | | pStep->setName(STEP_EQ_FAC_DATA_REPORT); |
| | | pStep->setProp("Port", (void*)1); |
| | | pStep->setWriteSignalDev(0xc4d); |
| | | if (addStep(STEP_ID_FAC_DATA_REPORT, pStep) != 0) { |
| | | delete pStep; |
| | | } |
| | | } |
| | | */ |
| | | |
| | | // process start/end report |
| | | { |
| | | CEqReadStep* pStep = new CEqReadStep(0x15D3F, 13 * 2, |
| | |
| | | |
| | | return (int)params.size(); |
| | | } |
| | | |
| | | int CVacuumBake::parsingProcessData(const char* pszData, size_t size, std::vector<CParam>& params) |
| | | { |
| | | return parsingParams(pszData, size, params); |
| | | } |
| | | |
| | | int CVacuumBake::parsingSVData(const char* pszData, size_t size, std::vector<CParam>& params) |
| | | { |
| | | /* |
| | | 1 Aè
å·¥èºè¿è¡æ¥éª¤ 1Word 123456 |
| | | 2 Aè
ä½ç空è§å¼ FLOAT 123.456 |
| | | 3 Aè
温æ§è¡¨1å½åå¼ 2Word 12345.6 |
| | | 4 Aè
温æ§è¡¨2å½åå¼ 2Word 12345.6 |
| | | 5 Aè
温æ§è¡¨4å½åå¼ 2Word 12345.6 |
| | | 6 Aè
温æ§è¡¨5å½åå¼ 2Word 12345.6 |
| | | 7 Aè
温æ§è¡¨6å½åå¼ 2Word 12345.6 |
| | | 8 Aè
温æ§è¡¨7å½åå¼ 2Word 12345.6 |
| | | 9 Aè
çç¤å©ä½æ¶é´ 1Word 12345.6 |
| | | 10 Bè
å·¥èºè¿è¡æ¥éª¤ 1Word 123456 |
| | | 11 Bè
ä½ç空è§å¼ FLOBT 123.456 |
| | | 12 Bè
温æ§è¡¨1å½åå¼ 2Word 12345.6 |
| | | 13 Bè
温æ§è¡¨2å½åå¼ 2Word 12345.6 |
| | | 14 Bè
温æ§è¡¨4å½åå¼ 2Word 12345.6 |
| | | 15 Bè
温æ§è¡¨5å½åå¼ 2Word 12345.6 |
| | | 16 Bè
温æ§è¡¨6å½åå¼ 2Word 12345.6 |
| | | 17 Bè
温æ§è¡¨7å½åå¼ 2Word 12345.6 |
| | | 18 Bè
çç¤å©ä½æ¶é´ 1Word 12345.6 |
| | | */ |
| | | |
| | | ASSERT(pszData); |
| | | if (size < 125) return 0; |
| | | int i = 0, v; |
| | | |
| | | |
| | | // 1.Aè
å·¥èºè¿è¡æ¥éª¤ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8; |
| | | params.push_back(CParam("Aè
å·¥èºè¿è¡æ¥éª¤", "", this->getName().c_str(), v)); |
| | | i += 2; |
| | | |
| | | // 2.Aè
ä½ç空è§å¼ |
| | | params.push_back(CParam("Aè
ä½ç空è§å¼", "", this->getName().c_str(), (double)toFloat(&pszData[i]))); |
| | | i += 4; |
| | | |
| | | // 3.Aè
温æ§è¡¨1å½åå¼ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8 | (pszData[i + 2] & 0xff) << 16 | (pszData[i + 3] & 0xff) << 24; |
| | | params.push_back(CParam("Aè
温æ§è¡¨1å½åå¼", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 4; |
| | | |
| | | // 4.Aè
温æ§è¡¨2å½åå¼ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8 | (pszData[i + 2] & 0xff) << 16 | (pszData[i + 3] & 0xff) << 24; |
| | | params.push_back(CParam("Aè
温æ§è¡¨2å½åå¼", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 4; |
| | | |
| | | // 5.Aè
温æ§è¡¨4å½åå¼ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8 | (pszData[i + 2] & 0xff) << 16 | (pszData[i + 3] & 0xff) << 24; |
| | | params.push_back(CParam("Aè
温æ§è¡¨4å½åå¼", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 4; |
| | | |
| | | // 6.Aè
温æ§è¡¨5å½åå¼ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8 | (pszData[i + 2] & 0xff) << 16 | (pszData[i + 3] & 0xff) << 24; |
| | | params.push_back(CParam("Aè
温æ§è¡¨5å½åå¼", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 4; |
| | | |
| | | // 7.Aè
温æ§è¡¨6å½åå¼ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8 | (pszData[i + 2] & 0xff) << 16 | (pszData[i + 3] & 0xff) << 24; |
| | | params.push_back(CParam("Aè
温æ§è¡¨6å½åå¼", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 4; |
| | | |
| | | // 8.Aè
温æ§è¡¨7å½åå¼ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8 | (pszData[i + 2] & 0xff) << 16 | (pszData[i + 3] & 0xff) << 24; |
| | | params.push_back(CParam("Aè
温æ§è¡¨7å½åå¼", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 4; |
| | | |
| | | // 9.Aè
çç¤å©ä½æ¶é´ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8; |
| | | params.push_back(CParam("Aè
çç¤å©ä½æ¶é´", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 2; |
| | | |
| | | // 10.Bè
å·¥èºè¿è¡æ¥éª¤ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8; |
| | | params.push_back(CParam("Bè
å·¥èºè¿è¡æ¥éª¤", "", this->getName().c_str(), v)); |
| | | i += 2; |
| | | |
| | | // 11.Aè
ä½ç空è§å¼ |
| | | params.push_back(CParam("Bè
ä½ç空è§å¼", "", this->getName().c_str(), (double)toFloat(&pszData[i]))); |
| | | i += 4; |
| | | |
| | | // 12.Bè
温æ§è¡¨1å½åå¼ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8 | (pszData[i + 2] & 0xff) << 16 | (pszData[i + 3] & 0xff) << 24; |
| | | params.push_back(CParam("Bè
温æ§è¡¨1å½åå¼", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 4; |
| | | |
| | | // 13.Bè
温æ§è¡¨2å½åå¼ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8 | (pszData[i + 2] & 0xff) << 16 | (pszData[i + 3] & 0xff) << 24; |
| | | params.push_back(CParam("Bè
温æ§è¡¨2å½åå¼", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 4; |
| | | |
| | | // 14.Bè
温æ§è¡¨4å½åå¼ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8 | (pszData[i + 2] & 0xff) << 16 | (pszData[i + 3] & 0xff) << 24; |
| | | params.push_back(CParam("Bè
温æ§è¡¨4å½åå¼", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 4; |
| | | |
| | | // 15.Bè
温æ§è¡¨5å½åå¼ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8 | (pszData[i + 2] & 0xff) << 16 | (pszData[i + 3] & 0xff) << 24; |
| | | params.push_back(CParam("Bè
温æ§è¡¨5å½åå¼", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 4; |
| | | |
| | | // 16.Bè
温æ§è¡¨6å½åå¼ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8 | (pszData[i + 2] & 0xff) << 16 | (pszData[i + 3] & 0xff) << 24; |
| | | params.push_back(CParam("Bè
温æ§è¡¨6å½åå¼", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 4; |
| | | |
| | | // 17.Bè
温æ§è¡¨7å½åå¼ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8 | (pszData[i + 2] & 0xff) << 16 | (pszData[i + 3] & 0xff) << 24; |
| | | params.push_back(CParam("Bè
温æ§è¡¨7å½åå¼", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 4; |
| | | |
| | | // 18.Bè
çç¤å©ä½æ¶é´ |
| | | v = (pszData[i] & 0xff) | (pszData[i + 1] & 0xff) << 8; |
| | | params.push_back(CParam("Bè
çç¤å©ä½æ¶é´", "", this->getName().c_str(), v * 0.1f)); |
| | | i += 2; |
| | | |
| | | return (int)params.size(); |
| | | } |
| | | } |
| | |
| | | virtual int recvIntent(CPin* pPin, CIntent* pIntent); |
| | | virtual int getIndexerOperationModeBaseValue(); |
| | | virtual int parsingParams(const char* pszData, size_t size, std::vector<CParam>& parsms); |
| | | virtual int parsingProcessData(const char* pszData, size_t size, std::vector<CParam>& parsms); |
| | | virtual int parsingSVData(const char* pszData, size_t size, std::vector<CParam>& parsms); |
| | | }; |
| | | } |
| | | |
| | |
| | | // TODO: 卿¤æ·»å é¢å¤çåå§å |
| | | SERVO::CEquipment* pEquipment = theApp.m_model.m_master.getEquipment(m_nDeviceID); |
| | | if (nullptr == pEquipment) { |
| | | LOGI("<设å¤IDï¼%d>è·å设å¤å±æ§å¤±è´¥ã", m_nDeviceID); |
| | | LOGE("<设å¤IDï¼%d>è·å设å¤å±æ§å¤±è´¥ã", m_nDeviceID); |
| | | return FALSE; |
| | | } |
| | | |
| | |
| | | Json::Value n(Json::objectValue); |
| | | n["eq_id"] = p->getEqID(); |
| | | n["unit"] = p->getUnit(); |
| | | n["slot"] = p->getUnit(); |
| | | put_ull_as_str(n, "time_in", static_cast<unsigned long long>(p->getInTime())); |
| | | put_ull_as_str(n, "time_out", static_cast<unsigned long long>(p->getOutTime())); |
| | | n["processed"] = p->isProcessEnd() ? true : false; |
| | |
| | | // åºæ¬ |
| | | g.setID(JStr(root, "id").c_str()); |
| | | g.setType(static_cast<MaterialsType>(JInt(root, "materials", 0))); |
| | | g.getBuddyId() = JStr(root, "buddy_id"); |
| | | g.setBuddyId(JStr(root, "buddy_id")); |
| | | g.setScheduledForProcessing(JBool(root, "scheduled") ? TRUE : FALSE); |
| | | g.m_failReason = JStr(root, "fail_reason"); |
| | | g.setOriginPort(JInt(root, "origin_port", 0), JInt(root, "origin_slot", 0)); |
| | |
| | | for (const auto& n : root["path"]) { |
| | | unsigned eq = JUInt(n, "eq_id", 0); |
| | | unsigned unit = JUInt(n, "unit", 0); |
| | | g.addPath(eq, unit); |
| | | unsigned slot = JUInt(n, "slot", 0); |
| | | g.addPath(eq, unit, slot); |
| | | |
| | | CPath* tail = nullptr; |
| | | if (auto head = g.getPath()) tail = head->getTailPath(); |
| ¶Ô±ÈÐÂÎļþ |
| | |
| | | // GlassLogDb.cpp - åä¾å°è£
ï¼SQLite åå
¥/æ¥è¯¢/å页/ç»è®¡/CSV 导åºï¼å·²å¯¹æ¥ SERVO::CGlassï¼ |
| | | #include "stdafx.h" |
| | | #include "GlassLogDb.h" |
| | | #include "sqlite3.h" |
| | | #include <stdexcept> |
| | | #include <sstream> |
| | | #include <iomanip> |
| | | #include <ctime> |
| | | #include <fstream> |
| | | #include "GlassJson.h" |
| | | |
| | | |
| | | using namespace SERVO; |
| | | |
| | | #ifndef GLASS_LOG_TABLE |
| | | #define GLASS_LOG_TABLE "glass_log" |
| | | #endif |
| | | |
| | | // ================== å·¥å
·å½æ° ================== |
| | | static void throwIf(int rc, sqlite3* db, const char* msg) { |
| | | if (rc != SQLITE_OK && rc != SQLITE_DONE && rc != SQLITE_ROW) { |
| | | std::ostringstream oss; |
| | | oss << msg << " (rc=" << rc << "): " << (db ? sqlite3_errmsg(db) : "null db"); |
| | | throw std::runtime_error(oss.str()); |
| | | } |
| | | } |
| | | static inline const char* safe_text(sqlite3_stmt* s, int col) { |
| | | const unsigned char* p = sqlite3_column_text(s, col); |
| | | return p ? reinterpret_cast<const char*>(p) : ""; |
| | | } |
| | | static std::string csvEscape(const std::string& s) { |
| | | bool needQuote = s.find_first_of(",\"\n\r") != std::string::npos; |
| | | if (!needQuote) return s; |
| | | std::string out; out.reserve(s.size() + 2); |
| | | out.push_back('"'); |
| | | for (char c : s) out += (c == '"') ? "\"\"" : std::string(1, c); |
| | | out.push_back('"'); |
| | | return out; |
| | | } |
| | | static std::string toIso8601String(const std::optional<std::chrono::system_clock::time_point>& tp) { |
| | | if (!tp.has_value()) return ""; |
| | | using namespace std::chrono; |
| | | auto t = system_clock::to_time_t(*tp); |
| | | std::tm tm{}; |
| | | #if defined(_WIN32) |
| | | gmtime_s(&tm, &t); |
| | | #else |
| | | gmtime_r(&t, &tm); |
| | | #endif |
| | | std::ostringstream oss; |
| | | oss << std::put_time(&tm, "%Y-%m-%dT%H:%M:%SZ"); |
| | | return oss.str(); |
| | | } |
| | | |
| | | // ================== åä¾éææå ================== |
| | | std::unique_ptr<GlassLogDb> GlassLogDb::s_inst; |
| | | std::mutex GlassLogDb::s_instMtx; |
| | | |
| | | // ================== å便¥å£å®ç° ================== |
| | | void GlassLogDb::Init(const std::string& dbPath) { |
| | | std::lock_guard<std::mutex> g(s_instMtx); |
| | | if (!s_inst) { |
| | | s_inst.reset(new GlassLogDb(dbPath)); |
| | | } |
| | | else if (s_inst->dbPath_ != dbPath) { |
| | | s_inst->reopenInternal(dbPath); |
| | | } |
| | | } |
| | | GlassLogDb& GlassLogDb::Instance() { |
| | | std::lock_guard<std::mutex> g(s_instMtx); |
| | | if (!s_inst) throw std::runtime_error("GlassLogDb::Instance() called before Init()"); |
| | | return *s_inst; |
| | | } |
| | | bool GlassLogDb::IsInitialized() noexcept { |
| | | std::lock_guard<std::mutex> g(s_instMtx); |
| | | return static_cast<bool>(s_inst); |
| | | } |
| | | void GlassLogDb::Reopen(const std::string& dbPath) { |
| | | std::lock_guard<std::mutex> g(s_instMtx); |
| | | if (!s_inst) { |
| | | s_inst.reset(new GlassLogDb(dbPath)); |
| | | } |
| | | else { |
| | | s_inst->reopenInternal(dbPath); |
| | | } |
| | | } |
| | | std::string GlassLogDb::CurrentPath() { |
| | | std::lock_guard<std::mutex> g(s_instMtx); |
| | | return s_inst ? s_inst->dbPath_ : std::string(); |
| | | } |
| | | |
| | | // ================== æé /æå¼/å
³é/éå¼ ================== |
| | | GlassLogDb::GlassLogDb(const std::string& dbPath) { |
| | | openDb(dbPath); |
| | | } |
| | | void GlassLogDb::openDb(const std::string& dbPath) { |
| | | int rc = sqlite3_open_v2(dbPath.c_str(), &db_, |
| | | SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX, |
| | | nullptr); |
| | | if (rc != SQLITE_OK) { |
| | | std::string err = db_ ? sqlite3_errmsg(db_) : "open failed"; |
| | | if (db_) sqlite3_close(db_); |
| | | db_ = nullptr; |
| | | throw std::runtime_error("Failed to open sqlite DB: " + err + " | path=" + dbPath); |
| | | } |
| | | dbPath_ = dbPath; |
| | | ensureSchema(); |
| | | prepareStatements(); |
| | | } |
| | | void GlassLogDb::closeDb() noexcept { |
| | | finalizeStatements(); |
| | | if (db_) { |
| | | sqlite3_close(db_); |
| | | db_ = nullptr; |
| | | } |
| | | } |
| | | void GlassLogDb::reopenInternal(const std::string& dbPath) { |
| | | std::lock_guard<std::mutex> lk(mtx_); |
| | | if (dbPath == dbPath_) return; |
| | | closeDb(); |
| | | openDb(dbPath); |
| | | } |
| | | |
| | | // ================== ææ ================== |
| | | GlassLogDb::~GlassLogDb() { |
| | | closeDb(); |
| | | } |
| | | |
| | | // ================== DDL & é¢ç¼è¯ ================== |
| | | void GlassLogDb::ensureSchema() { |
| | | const char* ddl = |
| | | "CREATE TABLE IF NOT EXISTS " GLASS_LOG_TABLE " (" |
| | | " id INTEGER PRIMARY KEY AUTOINCREMENT," |
| | | " cassette_seq_no INTEGER," |
| | | " job_seq_no INTEGER," |
| | | " class_id TEXT," |
| | | " material_type INTEGER," |
| | | " state INTEGER," |
| | | " t_start TEXT," // ISO8601 UTCï¼å¯ä¸º NULLï¼ |
| | | " t_end TEXT," // ISO8601 UTCï¼å¯ä¸º NULLï¼ |
| | | " buddy_id TEXT," |
| | | " aoi_result INTEGER," |
| | | " path TEXT," |
| | | " params TEXT," |
| | | " pretty TEXT" |
| | | ");" |
| | | "CREATE INDEX IF NOT EXISTS idx_glass_key " |
| | | " ON " GLASS_LOG_TABLE " (cassette_seq_no, job_seq_no);" |
| | | "CREATE INDEX IF NOT EXISTS idx_class_id " |
| | | " ON " GLASS_LOG_TABLE " (class_id);" |
| | | "CREATE INDEX IF NOT EXISTS idx_t_start " |
| | | " ON " GLASS_LOG_TABLE " (t_start);"; |
| | | |
| | | char* errMsg = nullptr; |
| | | int rc = sqlite3_exec(db_, ddl, nullptr, nullptr, &errMsg); |
| | | if (rc != SQLITE_OK) { |
| | | std::string err = errMsg ? errMsg : "unknown"; |
| | | sqlite3_free(errMsg); |
| | | throw std::runtime_error("Failed to create schema: " + err); |
| | | } |
| | | } |
| | | void GlassLogDb::prepareStatements() { |
| | | const char* sql = |
| | | "INSERT INTO " GLASS_LOG_TABLE " (" |
| | | " cassette_seq_no, job_seq_no, class_id, material_type, state," |
| | | " t_start, t_end, buddy_id, aoi_result, path, params, pretty)" |
| | | " VALUES (?,?,?,?,?,?,?,?,?,?,?,?);"; |
| | | int rc = sqlite3_prepare_v2(db_, sql, -1, &stmtInsert_, nullptr); |
| | | throwIf(rc, db_, "prepare insert"); |
| | | } |
| | | void GlassLogDb::finalizeStatements() noexcept { |
| | | if (stmtInsert_) { |
| | | sqlite3_finalize(stmtInsert_); |
| | | stmtInsert_ = nullptr; |
| | | } |
| | | } |
| | | |
| | | // ================== äºå¡ ================== |
| | | void GlassLogDb::beginTransaction() { |
| | | std::lock_guard<std::mutex> lk(mtx_); |
| | | char* err = nullptr; |
| | | int rc = sqlite3_exec(db_, "BEGIN IMMEDIATE;", nullptr, nullptr, &err); |
| | | if (rc != SQLITE_OK) { |
| | | std::string e = err ? err : "unknown"; |
| | | sqlite3_free(err); |
| | | throw std::runtime_error("BEGIN failed: " + e); |
| | | } |
| | | } |
| | | void GlassLogDb::commit() { |
| | | std::lock_guard<std::mutex> lk(mtx_); |
| | | char* err = nullptr; |
| | | int rc = sqlite3_exec(db_, "COMMIT;", nullptr, nullptr, &err); |
| | | if (rc != SQLITE_OK) { |
| | | std::string e = err ? err : "unknown"; |
| | | sqlite3_free(err); |
| | | throw std::runtime_error("COMMIT failed: " + e); |
| | | } |
| | | } |
| | | void GlassLogDb::rollback() { |
| | | std::lock_guard<std::mutex> lk(mtx_); |
| | | char* err = nullptr; |
| | | sqlite3_exec(db_, "ROLLBACK;", nullptr, nullptr, &err); |
| | | if (err) sqlite3_free(err); |
| | | } |
| | | |
| | | // ================== æ¶é´æ ¼å¼ ================== |
| | | std::string GlassLogDb::toIso8601Utc(std::chrono::system_clock::time_point tp) { |
| | | using namespace std::chrono; |
| | | auto t = system_clock::to_time_t(tp); |
| | | std::tm tm{}; |
| | | #if defined(_WIN32) |
| | | gmtime_s(&tm, &t); |
| | | #else |
| | | gmtime_r(&t, &tm); |
| | | #endif |
| | | std::ostringstream oss; |
| | | oss << std::put_time(&tm, "%Y-%m-%dT%H:%M:%SZ"); |
| | | return oss.str(); |
| | | } |
| | | |
| | | // ================== æå
¥å®ç° ================== |
| | | long long GlassLogDb::doInsert( |
| | | int cassetteSeqNo, |
| | | int jobSeqNo, |
| | | const std::string& classId, |
| | | int materialType, |
| | | int state, |
| | | std::optional<std::chrono::system_clock::time_point> tStart, |
| | | std::optional<std::chrono::system_clock::time_point> tEnd, |
| | | const std::string& buddyId, |
| | | int aoiResult, |
| | | const std::string& pathDesc, |
| | | const std::string& paramsDesc, |
| | | const std::string& prettyString) |
| | | { |
| | | std::lock_guard<std::mutex> lk(mtx_); |
| | | int idx = 1; |
| | | throwIf(sqlite3_reset(stmtInsert_), db_, "reset insert"); |
| | | throwIf(sqlite3_clear_bindings(stmtInsert_), db_, "clear bindings"); |
| | | |
| | | throwIf(sqlite3_bind_int(stmtInsert_, idx++, cassetteSeqNo), db_, "bind cassette"); |
| | | throwIf(sqlite3_bind_int(stmtInsert_, idx++, jobSeqNo), db_, "bind job"); |
| | | throwIf(sqlite3_bind_text(stmtInsert_, idx++, classId.c_str(), -1, SQLITE_TRANSIENT), db_, "bind class_id"); |
| | | throwIf(sqlite3_bind_int(stmtInsert_, idx++, materialType), db_, "bind material_type"); |
| | | throwIf(sqlite3_bind_int(stmtInsert_, idx++, state), db_, "bind state"); |
| | | |
| | | if (tStart.has_value()) { |
| | | auto s = toIso8601Utc(*tStart); |
| | | throwIf(sqlite3_bind_text(stmtInsert_, idx++, s.c_str(), -1, SQLITE_TRANSIENT), db_, "bind t_start"); |
| | | } |
| | | else { |
| | | throwIf(sqlite3_bind_null(stmtInsert_, idx++), db_, "bind t_start null"); |
| | | } |
| | | if (tEnd.has_value()) { |
| | | auto e = toIso8601Utc(*tEnd); |
| | | throwIf(sqlite3_bind_text(stmtInsert_, idx++, e.c_str(), -1, SQLITE_TRANSIENT), db_, "bind t_end"); |
| | | } |
| | | else { |
| | | throwIf(sqlite3_bind_null(stmtInsert_, idx++), db_, "bind t_end null"); |
| | | } |
| | | |
| | | throwIf(sqlite3_bind_text(stmtInsert_, idx++, buddyId.c_str(), -1, SQLITE_TRANSIENT), db_, "bind buddy_id"); |
| | | throwIf(sqlite3_bind_int(stmtInsert_, idx++, aoiResult), db_, "bind aoi_result"); |
| | | throwIf(sqlite3_bind_text(stmtInsert_, idx++, pathDesc.c_str(), -1, SQLITE_TRANSIENT), db_, "bind path"); |
| | | throwIf(sqlite3_bind_text(stmtInsert_, idx++, paramsDesc.c_str(), -1, SQLITE_TRANSIENT), db_, "bind params"); |
| | | throwIf(sqlite3_bind_text(stmtInsert_, idx++, prettyString.c_str(), -1, SQLITE_TRANSIENT), db_, "bind pretty"); |
| | | |
| | | int rc = sqlite3_step(stmtInsert_); |
| | | throwIf(rc, db_, "insert step"); |
| | | return sqlite3_last_insert_rowid(db_); |
| | | } |
| | | |
| | | long long GlassLogDb::insertFromCGlass(CGlass& g) |
| | | { |
| | | const int cassette = static_cast<int>(g.getCassetteSequenceNo()); |
| | | const int job = static_cast<int>(g.getJobSequenceNo()); |
| | | const std::string& classId = g.getID(); |
| | | const int material = static_cast<int>(g.getType()); |
| | | const int state = static_cast<int>(g.state()); |
| | | const std::string& buddy = g.getBuddyId(); |
| | | const int aoiResult = static_cast<int>(g.getAOIInspResult()); |
| | | const std::string pathDesc = g.getPathDescription(); |
| | | const std::string paramsDesc = g.getParamsDescription(); |
| | | const std::string pretty = GlassJson::ToPrettyString(g); |
| | | |
| | | auto tStart = g.tStart(); |
| | | auto tEnd = g.tEnd(); |
| | | |
| | | return doInsert(cassette, job, classId, material, state, |
| | | tStart, tEnd, buddy, aoiResult, pathDesc, paramsDesc, pretty); |
| | | } |
| | | |
| | | long long GlassLogDb::insertExplicit( |
| | | int cassetteSeqNo, |
| | | int jobSeqNo, |
| | | const std::string& classId, |
| | | int materialType, |
| | | int state, |
| | | std::optional<std::chrono::system_clock::time_point> tStart, |
| | | std::optional<std::chrono::system_clock::time_point> tEnd, |
| | | const std::string& buddyId, |
| | | int aoiResult, |
| | | const std::string& pathDesc, |
| | | const std::string& paramsDesc, |
| | | const std::string& prettyString) |
| | | { |
| | | return doInsert(cassetteSeqNo, jobSeqNo, classId, materialType, state, |
| | | tStart, tEnd, buddyId, aoiResult, pathDesc, paramsDesc, prettyString); |
| | | } |
| | | |
| | | // ================== è¿æ»¤æé ï¼where + bindï¼ ================== |
| | | static std::string buildWhereSql(const GlassLogDb::Filters& f) { |
| | | std::ostringstream where; |
| | | bool first = true; |
| | | auto add = [&](const std::string& cond) { |
| | | if (first) { where << " WHERE " << cond; first = false; } |
| | | else { where << " AND " << cond; } |
| | | }; |
| | | if (f.classId) add("class_id = ?"); |
| | | if (f.cassetteSeqNo) add("cassette_seq_no = ?"); |
| | | if (f.jobSeqNo) add("job_seq_no = ?"); |
| | | if (f.keyword) add("(class_id LIKE ? OR buddy_id LIKE ? OR path LIKE ? OR params LIKE ? OR pretty LIKE ?)"); |
| | | if (f.tStartFrom && f.tStartTo) add("(t_start >= ? AND t_start <= ?)"); |
| | | else if (f.tStartFrom) add("t_start >= ?"); |
| | | else if (f.tStartTo) add("t_start <= ?"); |
| | | return where.str(); |
| | | } |
| | | static void bindFilters(sqlite3_stmt* stmt, sqlite3* db, int& idx, const GlassLogDb::Filters& f) { |
| | | if (f.classId) throwIf(sqlite3_bind_text(stmt, idx++, f.classId->c_str(), -1, SQLITE_TRANSIENT), db, "bind classId"); |
| | | if (f.cassetteSeqNo) throwIf(sqlite3_bind_int(stmt, idx++, *f.cassetteSeqNo), db, "bind cassette"); |
| | | if (f.jobSeqNo) throwIf(sqlite3_bind_int(stmt, idx++, *f.jobSeqNo), db, "bind job"); |
| | | if (f.keyword) { |
| | | std::string kw = "%" + *f.keyword + "%"; |
| | | for (int i = 0; i < 5; ++i) |
| | | throwIf(sqlite3_bind_text(stmt, idx++, kw.c_str(), -1, SQLITE_TRANSIENT), db, "bind keyword"); |
| | | } |
| | | if (f.tStartFrom && f.tStartTo) { |
| | | std::string s = toIso8601String(f.tStartFrom); |
| | | std::string e = toIso8601String(f.tStartTo); |
| | | throwIf(sqlite3_bind_text(stmt, idx++, s.c_str(), -1, SQLITE_TRANSIENT), db, "bind tStartFrom"); |
| | | throwIf(sqlite3_bind_text(stmt, idx++, e.c_str(), -1, SQLITE_TRANSIENT), db, "bind tStartTo"); |
| | | } |
| | | else if (f.tStartFrom) { |
| | | std::string s = toIso8601String(f.tStartFrom); |
| | | throwIf(sqlite3_bind_text(stmt, idx++, s.c_str(), -1, SQLITE_TRANSIENT), db, "bind tStartFrom"); |
| | | } |
| | | else if (f.tStartTo) { |
| | | std::string e = toIso8601String(f.tStartTo); |
| | | throwIf(sqlite3_bind_text(stmt, idx++, e.c_str(), -1, SQLITE_TRANSIENT), db, "bind tStartTo"); |
| | | } |
| | | } |
| | | |
| | | // ================== æ¥è¯¢ / ç»è®¡ / å页 ================== |
| | | std::vector<GlassLogDb::Row> GlassLogDb::query( |
| | | const Filters& filters, |
| | | int limit, |
| | | int offset) |
| | | { |
| | | std::lock_guard<std::mutex> lk(mtx_); |
| | | |
| | | std::ostringstream sql; |
| | | sql << "SELECT id, cassette_seq_no, job_seq_no, class_id, material_type, state," |
| | | " IFNULL(strftime('%Y-%m-%d %H:%M:%S', t_start, 'localtime'), '')," |
| | | " IFNULL(strftime('%Y-%m-%d %H:%M:%S', t_end, 'localtime'), '')," |
| | | " buddy_id, aoi_result, path, params, pretty" |
| | | " FROM " GLASS_LOG_TABLE; |
| | | |
| | | std::string where = buildWhereSql(filters); |
| | | sql << where |
| | | << " ORDER BY id DESC" |
| | | << " LIMIT " << (limit < 0 ? 0 : limit) |
| | | << " OFFSET " << (offset < 0 ? 0 : offset); |
| | | |
| | | sqlite3_stmt* stmt = nullptr; |
| | | throwIf(sqlite3_prepare_v2(db_, sql.str().c_str(), -1, &stmt, nullptr), db_, "prepare query"); |
| | | |
| | | int idx = 1; |
| | | bindFilters(stmt, db_, idx, filters); |
| | | |
| | | std::vector<Row> rows; |
| | | for (;;) { |
| | | int rc = sqlite3_step(stmt); |
| | | if (rc == SQLITE_ROW) { |
| | | Row r; |
| | | r.id = sqlite3_column_int64(stmt, 0); |
| | | r.cassetteSeqNo = sqlite3_column_int(stmt, 1); |
| | | r.jobSeqNo = sqlite3_column_int(stmt, 2); |
| | | r.classId = safe_text(stmt, 3); |
| | | r.materialType = sqlite3_column_int(stmt, 4); |
| | | r.state = sqlite3_column_int(stmt, 5); |
| | | r.tStart = safe_text(stmt, 6); |
| | | r.tEnd = safe_text(stmt, 7); |
| | | r.buddyId = safe_text(stmt, 8); |
| | | r.aoiResult = sqlite3_column_int(stmt, 9); |
| | | r.path = safe_text(stmt, 10); |
| | | r.params = safe_text(stmt, 11); |
| | | r.pretty = safe_text(stmt, 12); |
| | | rows.push_back(std::move(r)); |
| | | } |
| | | else if (rc == SQLITE_DONE) { |
| | | break; |
| | | } |
| | | else { |
| | | sqlite3_finalize(stmt); |
| | | throwIf(rc, db_, "query step"); |
| | | } |
| | | } |
| | | sqlite3_finalize(stmt); |
| | | return rows; |
| | | } |
| | | |
| | | long long GlassLogDb::count(const Filters& filters) { |
| | | std::lock_guard<std::mutex> lk(mtx_); |
| | | |
| | | std::ostringstream sql; |
| | | sql << "SELECT COUNT(1) FROM " GLASS_LOG_TABLE; |
| | | |
| | | std::string where = buildWhereSql(filters); |
| | | sql << where; |
| | | |
| | | sqlite3_stmt* stmt = nullptr; |
| | | throwIf(sqlite3_prepare_v2(db_, sql.str().c_str(), -1, &stmt, nullptr), db_, "prepare count"); |
| | | |
| | | int idx = 1; |
| | | bindFilters(stmt, db_, idx, filters); |
| | | |
| | | long long total = 0; |
| | | int rc = sqlite3_step(stmt); |
| | | if (rc == SQLITE_ROW) { |
| | | total = sqlite3_column_int64(stmt, 0); |
| | | } |
| | | else if (rc != SQLITE_DONE) { |
| | | sqlite3_finalize(stmt); |
| | | throwIf(rc, db_, "count step"); |
| | | } |
| | | sqlite3_finalize(stmt); |
| | | return total; |
| | | } |
| | | |
| | | GlassLogDb::Page GlassLogDb::queryPaged( |
| | | const Filters& filters, |
| | | int limit, |
| | | int offset) |
| | | { |
| | | Page p; |
| | | p.limit = (limit < 0 ? 0 : limit); |
| | | p.offset = (offset < 0 ? 0 : offset); |
| | | p.total = count(filters); |
| | | p.items = query(filters, p.limit, p.offset); |
| | | return p; |
| | | } |
| | | |
| | | // ================== å¯¼åº CSVï¼å
¨é¨ç¬¦åæ¡ä»¶ï¼ ================== |
| | | long long GlassLogDb::exportCsv(const std::string& csvPath, const Filters& filters) { |
| | | std::lock_guard<std::mutex> lk(mtx_); |
| | | |
| | | std::ofstream ofs(csvPath, std::ios::binary); |
| | | if (!ofs) { |
| | | throw std::runtime_error("Failed to open csv for write: " + csvPath); |
| | | } |
| | | |
| | | // 表头 |
| | | ofs << "id,cassette_seq_no,job_seq_no,class_id,material_type,state,t_start,t_end," |
| | | "buddy_id,aoi_result,path,params,pretty\n"; |
| | | |
| | | std::ostringstream sql; |
| | | sql << "SELECT id, cassette_seq_no, job_seq_no, class_id, material_type, state," |
| | | " IFNULL(strftime('%Y-%m-%d %H:%M:%S', t_start, 'localtime'), '')," |
| | | " IFNULL(strftime('%Y-%m-%d %H:%M:%S', t_end, 'localtime'), '')," |
| | | " buddy_id, aoi_result, path, params, pretty" |
| | | " FROM " GLASS_LOG_TABLE; |
| | | |
| | | std::string where = buildWhereSql(filters); |
| | | sql << where << " ORDER BY id DESC"; |
| | | |
| | | sqlite3_stmt* stmt = nullptr; |
| | | throwIf(sqlite3_prepare_v2(db_, sql.str().c_str(), -1, &stmt, nullptr), db_, "prepare export"); |
| | | |
| | | int idx = 1; |
| | | bindFilters(stmt, db_, idx, filters); |
| | | |
| | | long long rows = 0; |
| | | for (;;) { |
| | | int rc = sqlite3_step(stmt); |
| | | if (rc == SQLITE_ROW) { |
| | | std::string id = std::to_string(sqlite3_column_int64(stmt, 0)); |
| | | std::string cassette = std::to_string(sqlite3_column_int(stmt, 1)); |
| | | std::string job = std::to_string(sqlite3_column_int(stmt, 2)); |
| | | std::string class_id = safe_text(stmt, 3); |
| | | std::string material = std::to_string(sqlite3_column_int(stmt, 4)); |
| | | std::string state = std::to_string(sqlite3_column_int(stmt, 5)); |
| | | std::string t_start = safe_text(stmt, 6); |
| | | std::string t_end = safe_text(stmt, 7); |
| | | std::string buddy = safe_text(stmt, 8); |
| | | std::string aoi = std::to_string(sqlite3_column_int(stmt, 9)); |
| | | std::string path = safe_text(stmt, 10); |
| | | std::string params = safe_text(stmt, 11); |
| | | std::string pretty = safe_text(stmt, 12); |
| | | |
| | | ofs << id << ',' |
| | | << cassette << ',' |
| | | << job << ',' |
| | | << csvEscape(class_id) << ',' |
| | | << material << ',' |
| | | << state << ',' |
| | | << t_start << ',' |
| | | << t_end << ',' |
| | | << csvEscape(buddy) << ',' |
| | | << aoi << ',' |
| | | << csvEscape(path) << ',' |
| | | << csvEscape(params) << ',' |
| | | << csvEscape(pretty) << '\n'; |
| | | ++rows; |
| | | } |
| | | else if (rc == SQLITE_DONE) { |
| | | break; |
| | | } |
| | | else { |
| | | sqlite3_finalize(stmt); |
| | | throwIf(rc, db_, "export step"); |
| | | } |
| | | } |
| | | sqlite3_finalize(stmt); |
| | | ofs.flush(); |
| | | return rows; |
| | | } |
| ¶Ô±ÈÐÂÎļþ |
| | |
| | | #pragma once |
| | | // GlassLogDb.h - åä¾å°è£
ï¼SQLite åå
¥/æ¥è¯¢/å页/ç»è®¡/CSV 导åºï¼å·²å¯¹æ¥ SERVO::CGlassï¼ |
| | | |
| | | #include <string> |
| | | #include <vector> |
| | | #include <mutex> |
| | | #include <optional> |
| | | #include <chrono> |
| | | #include <cstdint> |
| | | #include <memory> // std::unique_ptr |
| | | |
| | | #include "CGlass.h" // éè¦ SERVO::CGlass |
| | | |
| | | // å¯å¨ç¼è¯å½ä»¤ææ¬å¤´æä»¶åèªå®ä¹è¡¨åï¼#define GLASS_LOG_TABLE "your_table_name" |
| | | #ifndef GLASS_LOG_TABLE |
| | | #define GLASS_LOG_TABLE "glass_log" |
| | | #endif |
| | | |
| | | // å置声æï¼é¿å
头æä»¶ä¾èµ sqlite3.h |
| | | struct sqlite3; |
| | | struct sqlite3_stmt; |
| | | |
| | | class GlassLogDb { |
| | | public: |
| | | // ====== å便¥å£ ====== |
| | | // åå§åï¼æåæ¢ï¼æ°æ®åºæä»¶è·¯å¾ï¼ç¬¬ä¸æ¬¡è°ç¨ä¼å建å®ä¾ |
| | | static void Init(const std::string& dbPath); |
| | | // è·åå
¨å±å®ä¾ï¼è¥æªåå§å伿å¼å¸¸ |
| | | static GlassLogDb& Instance(); |
| | | // æ¯å¦å·²åå§å |
| | | static bool IsInitialized() noexcept; |
| | | // è¿è¡ä¸åæ¢å°å¦ä¸ä»½æ°æ®åºæä»¶ï¼çå Initï¼ä¸åå¨ååå»ºï¼ |
| | | static void Reopen(const std::string& dbPath); |
| | | // å½åæ°æ®åºæä»¶è·¯å¾ï¼æªåå§åè¿åç©ºä¸²ï¼ |
| | | static std::string CurrentPath(); |
| | | |
| | | // ====== äºå¡æ§å¶ ====== |
| | | void beginTransaction(); |
| | | void commit(); |
| | | void rollback(); |
| | | |
| | | // ====== åå
¥ ====== |
| | | // ç´æ¥ä» SERVO::CGlass åå
¥ï¼æ³¨æï¼åæ°ä¸º é const å¼ç¨ï¼å ä¸ºä½ çè¥å¹² getter é constï¼ |
| | | long long insertFromCGlass(SERVO::CGlass& g); |
| | | |
| | | // æ¾å¼åæ°æå
¥ï¼tStart/tEnd å¯ç©ºï¼ååå
¥ UTC ISO8601 ææ¬æ NULLï¼ |
| | | long long insertExplicit( |
| | | int cassetteSeqNo, |
| | | int jobSeqNo, |
| | | const std::string& classId, |
| | | int materialType, |
| | | int state, |
| | | std::optional<std::chrono::system_clock::time_point> tStart, |
| | | std::optional<std::chrono::system_clock::time_point> tEnd, |
| | | const std::string& buddyId, |
| | | int aoiResult, |
| | | const std::string& pathDesc, |
| | | const std::string& paramsDesc, |
| | | const std::string& prettyString); |
| | | |
| | | // ====== æ¥è¯¢è¿åç»æ ====== |
| | | struct Row { |
| | | long long id = 0; |
| | | int cassetteSeqNo = 0; |
| | | int jobSeqNo = 0; |
| | | std::string classId; |
| | | int materialType = 0; |
| | | int state = 0; |
| | | std::string tStart; // ISO8601ï¼åºä¸ä¸º NULL åä¸ºç©ºä¸²ï¼ |
| | | std::string tEnd; // ISO8601ï¼åºä¸ä¸º NULL åä¸ºç©ºä¸²ï¼ |
| | | std::string buddyId; |
| | | int aoiResult = 0; |
| | | std::string path; |
| | | std::string params; |
| | | std::string pretty; |
| | | }; |
| | | |
| | | // ====== è¿æ»¤æ¡ä»¶ ====== |
| | | struct Filters { |
| | | std::optional<std::string> classId; // 精确å¹é
class_id |
| | | std::optional<int> cassetteSeqNo; |
| | | std::optional<int> jobSeqNo; |
| | | |
| | | // å
³é®å模ç³ï¼å¯¹ class_id / buddy_id / path / params / pretty å OR LIKE |
| | | std::optional<std::string> keyword; |
| | | |
| | | // æ¶é´èå´ï¼å¯¹ t_start è¿æ»¤ï¼å«è¾¹çï¼ISO8601 ææ¬æ¯è¾ï¼ |
| | | std::optional<std::chrono::system_clock::time_point> tStartFrom; |
| | | std::optional<std::chrono::system_clock::time_point> tStartTo; |
| | | }; |
| | | |
| | | // ====== æ¥è¯¢ / ç»è®¡ / å页 ====== |
| | | // å页æ¥è¯¢ï¼limit/offsetï¼ï¼æ id DESC |
| | | std::vector<Row> query( |
| | | const Filters& filters = {}, |
| | | int limit = 50, |
| | | int offset = 0); |
| | | |
| | | // ç»è®¡ä¸ filters ç¸åæ¡ä»¶çæ»æ° |
| | | long long count(const Filters& filters = {}); |
| | | |
| | | struct Page { |
| | | std::vector<Row> items; // å½åé¡µæ°æ® |
| | | long long total = 0; // ç¬¦åæ¡ä»¶çæ»è®°å½æ° |
| | | int limit = 0; // æ¬æ¬¡æ¥è¯¢ç页容é |
| | | int offset = 0; // æ¬æ¬¡æ¥è¯¢çèµ·å§åç§» |
| | | }; |
| | | // 䏿¬¡ååå表 + æ»æ° |
| | | Page queryPaged( |
| | | const Filters& filters = {}, |
| | | int limit = 50, |
| | | int offset = 0); |
| | | |
| | | // ====== å¯¼åº ====== |
| | | // å¯¼åºæ»¡è¶³ filters çâå
¨é¨è®°å½âï¼ä¸åå页éå¶ï¼ä¸º CSVï¼UTF-8ï¼ |
| | | // è¿åååºçæ°æ®è¡æ°ï¼ä¸å«è¡¨å¤´ï¼ |
| | | long long exportCsv(const std::string& csvPath, const Filters& filters = {}); |
| | | |
| | | // ====== ææ / æ·è´æ§å¶ ====== |
| | | ~GlassLogDb(); |
| | | GlassLogDb(const GlassLogDb&) = delete; |
| | | GlassLogDb& operator=(const GlassLogDb&) = delete; |
| | | |
| | | private: |
| | | // ä»
å
许éè¿å便¥å£æé |
| | | explicit GlassLogDb(const std::string& dbPath); |
| | | |
| | | // å
鍿å¼/å
³é/éå¼ |
| | | void openDb(const std::string& dbPath); |
| | | void closeDb() noexcept; |
| | | void reopenInternal(const std::string& dbPath); |
| | | |
| | | // 建表 / é¢ç¼è¯ / éæ¾ |
| | | void ensureSchema(); |
| | | void prepareStatements(); |
| | | void finalizeStatements() noexcept; |
| | | |
| | | // å·¥å
·ï¼time_point -> "YYYY-MM-DDTHH:MM:SSZ"ï¼UTCï¼ |
| | | static std::string toIso8601Utc(std::chrono::system_clock::time_point tp); |
| | | |
| | | // å®é
æå
¥æ§è¡ï¼æ¯æå¯ç©ºæ¶é´ï¼ |
| | | long long doInsert( |
| | | int cassetteSeqNo, |
| | | int jobSeqNo, |
| | | const std::string& classId, |
| | | int materialType, |
| | | int state, |
| | | std::optional<std::chrono::system_clock::time_point> tStart, |
| | | std::optional<std::chrono::system_clock::time_point> tEnd, |
| | | const std::string& buddyId, |
| | | int aoiResult, |
| | | const std::string& pathDesc, |
| | | const std::string& paramsDesc, |
| | | const std::string& prettyString); |
| | | |
| | | private: |
| | | // SQLite 奿 |
| | | sqlite3* db_ = nullptr; |
| | | sqlite3_stmt* stmtInsert_ = nullptr; |
| | | |
| | | // å®ä¾å
å¹¶åä¿æ¤ï¼åä¸è¿æ¥ä¸çå/读串è¡åï¼ |
| | | std::mutex mtx_; |
| | | |
| | | // å½åæ°æ®åºæä»¶è·¯å¾ |
| | | std::string dbPath_; |
| | | |
| | | // åä¾éæå¯¹è±¡ä¸å
¶äºæ¥ |
| | | static std::unique_ptr<GlassLogDb> s_inst; |
| | | static std::mutex s_instMtx; |
| | | }; |
| | |
| | | { |
| | | // æ ¹æ®å¨ SetItemColor(DWORD iItem, COLORREF color) 设置ç |
| | | // ITEMå·åCOLORREF 卿¸æ¿ä¸æ¥æ¾ï¼ç¶åè¿è¡é¢è²èµå¼ã |
| | | //LISTITEMEX_9& itemex = m_listItemColor.GetAt(m_listItemColor.FindIndex(nmcd.dwItemSpec)); |
| | | //lplvdr->clrText = itemex.colText; |
| | | //lplvdr->clrTextBk = itemex.colTextBk; |
| | | //*pResult = CDRF_DODEFAULT; |
| | | LISTITEMEX_9& itemex = m_listItemColor.GetAt(m_listItemColor.FindIndex(nmcd.dwItemSpec)); |
| | | lplvdr->clrText = itemex.colText; |
| | | lplvdr->clrTextBk = itemex.colTextBk; |
| | | *pResult = CDRF_DODEFAULT; |
| | | |
| | | /* |
| | | if (nmcd.dwItemSpec % 2 == 0) { |
| | | lplvdr->clrText = RGB(0, 0, 0); |
| | | lplvdr->clrTextBk = RGB(235, 235, 235); |
| | |
| | | lplvdr->clrTextBk = RGB(255, 255, 255); |
| | | *pResult = CDRF_DODEFAULT; |
| | | } |
| | | |
| | | */ |
| | | |
| | | break; |
| | | } |
| | |
| | | #include "CGlassPool.h" |
| | | #include "TransferManager.h" |
| | | #include "RecipeManager.h" |
| | | #include "GlassLogDb.h" |
| | | |
| | | |
| | | CModel::CModel() |
| | |
| | | m_hsmsPassive.setVariableValue("PJEndID", ((SERVO::CProcessJob*)pj)->id().c_str()); |
| | | m_hsmsPassive.requestEventReportSend_PJ_End(); |
| | | }; |
| | | masterListener.onPanelStart = [&](void* pMaster, void* pj) { |
| | | m_hsmsPassive.setVariableValue("PanelStartID", ((SERVO::CGlass*)pj)->getID().c_str()); |
| | | masterListener.onPanelStart = [&](void* pMaster, void* pPanel) { |
| | | m_hsmsPassive.setVariableValue("PanelStartID", ((SERVO::CGlass*)pPanel)->getID().c_str()); |
| | | m_hsmsPassive.requestEventReportSend_Panel_Start(); |
| | | }; |
| | | masterListener.onPanelEnd = [&](void* pMaster, void* pj) { |
| | | m_hsmsPassive.setVariableValue("PanelEndID", ((SERVO::CGlass*)pj)->getID().c_str()); |
| | | masterListener.onPanelEnd = [&](void* pMaster, void* pPanel) { |
| | | m_hsmsPassive.setVariableValue("PanelEndID", ((SERVO::CGlass*)pPanel)->getID().c_str()); |
| | | m_hsmsPassive.requestEventReportSend_Panel_End(); |
| | | auto& db = GlassLogDb::Instance(); |
| | | db.insertFromCGlass((*(SERVO::CGlass*)pPanel)); |
| | | }; |
| | | m_master.setListener(masterListener); |
| | | m_master.setContinuousTransferCount(m_configuration.getContinuousTransferCount()); |
| | |
| | | alarmManager.readAlarmFile(szBuffer); |
| | | |
| | | |
| | | // Glassæ°æ®åº |
| | | strLogDir.Format(_T("%s\\db\\process.db"), (LPTSTR)(LPCTSTR)m_strWorkDir); |
| | | std::string path((LPTSTR)(LPCTSTR)strLogDir); |
| | | GlassLogDb::Init(path); |
| | | |
| | | |
| | | return 0; |
| | | } |
| | |
| | | <ClInclude Include="CPagePortStatus.h" /> |
| | | <ClInclude Include="CPortStatusReport.h" /> |
| | | <ClInclude Include="CRobotTaskDlg.h" /> |
| | | <ClInclude Include="CSVData.h" /> |
| | | <ClInclude Include="CServoUtilsTool.h" /> |
| | | <ClInclude Include="CVariable.h" /> |
| | | <ClInclude Include="DeviceRecipeParamDlg.h" /> |
| | | <ClInclude Include="GlassJson.h" /> |
| | | <ClInclude Include="GlassLogDb.h" /> |
| | | <ClInclude Include="GridControl\CellRange.h" /> |
| | | <ClInclude Include="GridControl\GridCell.h" /> |
| | | <ClInclude Include="GridControl\GridCellBase.h" /> |
| | |
| | | <ClInclude Include="ServoDlg.h" /> |
| | | <ClInclude Include="ServoGraph.h" /> |
| | | <ClInclude Include="ServoMemDC.h" /> |
| | | <ClInclude Include="sqlite3.h" /> |
| | | <ClInclude Include="sqlite3ext.h" /> |
| | | <ClInclude Include="stdafx.h" /> |
| | | <ClInclude Include="SystemLogManager.h" /> |
| | | <ClInclude Include="SystemLogManagerDlg.h" /> |
| | |
| | | <ClCompile Include="CPagePortStatus.cpp" /> |
| | | <ClCompile Include="CPortStatusReport.cpp" /> |
| | | <ClCompile Include="CRobotTaskDlg.cpp" /> |
| | | <ClCompile Include="CSVData.cpp" /> |
| | | <ClCompile Include="CServoUtilsTool.cpp" /> |
| | | <ClCompile Include="CVariable.cpp" /> |
| | | <ClCompile Include="DeviceRecipeParamDlg.cpp" /> |
| | | <ClCompile Include="GlassJson.cpp" /> |
| | | <ClCompile Include="GlassLogDb.cpp" /> |
| | | <ClCompile Include="GridControl\GridCell.cpp" /> |
| | | <ClCompile Include="GridControl\GridCellBase.cpp" /> |
| | | <ClCompile Include="GridControl\GridCellButton.cpp" /> |
| | |
| | | <ClCompile Include="ServoDlg.cpp" /> |
| | | <ClCompile Include="ServoGraph.cpp" /> |
| | | <ClCompile Include="ServoMemDC.cpp" /> |
| | | <ClCompile Include="sqlite3.c"> |
| | | <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">NotUsing</PrecompiledHeader> |
| | | <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">NotUsing</PrecompiledHeader> |
| | | </ClCompile> |
| | | <ClCompile Include="stdafx.cpp"> |
| | | <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader> |
| | | <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader> |
| | |
| | | <Filter>JsonCpp</Filter> |
| | | </ClCompile> |
| | | <ClCompile Include="DeviceRecipeParamDlg.cpp" /> |
| | | <ClCompile Include="CSVData.cpp" /> |
| | | <ClCompile Include="CServoUtilsTool.cpp" /> |
| | | <ClCompile Include="GlassLogDb.cpp" /> |
| | | <ClCompile Include="sqlite3.c" /> |
| | | </ItemGroup> |
| | | <ItemGroup> |
| | | <ClInclude Include="AlarmManager.h" /> |
| | |
| | | <Filter>JsonCpp</Filter> |
| | | </ClInclude> |
| | | <ClInclude Include="DeviceRecipeParamDlg.h" /> |
| | | <ClInclude Include="CSVData.h" /> |
| | | <ClInclude Include="CServoUtilsTool.h" /> |
| | | <ClInclude Include="GlassLogDb.h" /> |
| | | <ClInclude Include="sqlite3.h" /> |
| | | <ClInclude Include="sqlite3ext.h" /> |
| | | </ItemGroup> |
| | | <ItemGroup> |
| | | <ResourceCompile Include="Servo.rc" /> |
| | |
| | | #include <chrono> |
| | | #include <memory> |
| | | #include <sstream> |
| | | #include <algorithm> |
| | | |
| | | |
| | | CToolUnits::CToolUnits() |
| | |
| | | strOut = std::string(pszBuffer, nLength); |
| | | } |
| | | } |
| | | |
| | | // FILETIME(UTC) -> time_point |
| | | std::chrono::system_clock::time_point CToolUnits::FileTimeToTimePointUTC(const FILETIME& ftUtc) { |
| | | ULARGE_INTEGER ull; |
| | | ull.LowPart = ftUtc.dwLowDateTime; |
| | | ull.HighPart = ftUtc.dwHighDateTime; |
| | | // 1601-01-01 å° 1970-01-01 ç 100ns tick |
| | | constexpr unsigned long long EPOCH_DIFF_100NS = 116444736000000000ULL; |
| | | unsigned long long t100 = ull.QuadPart - EPOCH_DIFF_100NS; // 1970ä»¥æ¥ 100ns |
| | | // é¿å
溢åºï¼100ns -> us |
| | | unsigned long long us = t100 / 10ULL; |
| | | return std::chrono::system_clock::time_point(std::chrono::microseconds(us)); |
| | | } |
| | | |
| | | // ä» CDateTimeCtrl 忬尿¶é´å¹¶è½¬ä¸º UTC time_point |
| | | // è¿å false 表示æ§ä»¶æ¯âæ å¼â(DTS_SHOWNONE / GDT_NONE) æè½¬æ¢å¤±è´¥ |
| | | bool CToolUnits::GetCtrlTimeUtc(const CDateTimeCtrl& ctrl, |
| | | std::chrono::system_clock::time_point& outUtc) |
| | | { |
| | | SYSTEMTIME stLocal{}; |
| | | DWORD rc = const_cast<CDateTimeCtrl&>(ctrl).GetTime(&stLocal); // MFC ååéè¦éconst |
| | | if (rc != GDT_VALID) return false; // GDT_NONE |
| | | |
| | | SYSTEMTIME stUtc{}; |
| | | if (!TzSpecificLocalTimeToSystemTime(nullptr, &stLocal, &stUtc)) return false; |
| | | |
| | | FILETIME ftUtc{}; |
| | | if (!SystemTimeToFileTime(&stUtc, &ftUtc)) return false; |
| | | |
| | | outUtc = FileTimeToTimePointUTC(ftUtc); |
| | | return true; |
| | | } |
| | | |
| | | // è¥ä½ çæ¥ææ§ä»¶åªæ¾ç¤ºâæ¥æä¸æ¾ç¤ºæ¶é´âï¼æ³æ From è°æ´å° 00:00:00 / To è°æ´å° 23:59:59.999ï¼ |
| | | bool CToolUnits::GetCtrlDateRangeUtc_StartOfDay(const CDateTimeCtrl& ctrl, |
| | | std::chrono::system_clock::time_point& outUtc) |
| | | { |
| | | SYSTEMTIME st{}; |
| | | DWORD rc = const_cast<CDateTimeCtrl&>(ctrl).GetTime(&st); |
| | | if (rc != GDT_VALID) return false; |
| | | st.wHour = 0; st.wMinute = 0; st.wSecond = 0; st.wMilliseconds = 0; |
| | | |
| | | SYSTEMTIME stUtc{}; |
| | | if (!TzSpecificLocalTimeToSystemTime(nullptr, &st, &stUtc)) return false; |
| | | FILETIME ftUtc{}; if (!SystemTimeToFileTime(&stUtc, &ftUtc)) return false; |
| | | outUtc = FileTimeToTimePointUTC(ftUtc); |
| | | return true; |
| | | } |
| | | |
| | | bool CToolUnits::GetCtrlDateRangeUtc_EndOfDay(const CDateTimeCtrl& ctrl, |
| | | std::chrono::system_clock::time_point& outUtc) |
| | | { |
| | | SYSTEMTIME st{}; |
| | | DWORD rc = const_cast<CDateTimeCtrl&>(ctrl).GetTime(&st); |
| | | if (rc != GDT_VALID) return false; |
| | | st.wHour = 23; st.wMinute = 59; st.wSecond = 59; st.wMilliseconds = 999; |
| | | |
| | | SYSTEMTIME stUtc{}; |
| | | if (!TzSpecificLocalTimeToSystemTime(nullptr, &st, &stUtc)) return false; |
| | | FILETIME ftUtc{}; if (!SystemTimeToFileTime(&stUtc, &ftUtc)) return false; |
| | | outUtc = FileTimeToTimePointUTC(ftUtc); |
| | | return true; |
| | | } |
| | | |
| | | // ---------- æ¬å° SYSTEMTIME -> UTC time_point ---------- |
| | | std::chrono::system_clock::time_point CToolUnits::LocalSTtoUtcTP(const SYSTEMTIME& stLocal) { |
| | | SYSTEMTIME stUtc{}; |
| | | if (!TzSpecificLocalTimeToSystemTime(nullptr, &stLocal, &stUtc)) |
| | | throw std::runtime_error("TzSpecificLocalTimeToSystemTime failed"); |
| | | FILETIME ftUtc{}; |
| | | if (!SystemTimeToFileTime(&stUtc, &ftUtc)) |
| | | throw std::runtime_error("SystemTimeToFileTime failed"); |
| | | return FileTimeToTimePointUTC(ftUtc); |
| | | } |
| | | |
| | | // çææ¬å° SYSTEMTIME |
| | | SYSTEMTIME CToolUnits::MakeLocalST(int y, int m, int d, int hh, int mi, int ss, int ms) { |
| | | SYSTEMTIME st{}; |
| | | st.wYear = (WORD)y; st.wMonth = (WORD)m; st.wDay = (WORD)d; |
| | | st.wHour = (WORD)hh; st.wMinute = (WORD)mi; st.wSecond = (WORD)ss; st.wMilliseconds = (WORD)ms; |
| | | return st; |
| | | } |
| | | |
| | | // é°å¹´ / æå¤©æ° |
| | | bool CToolUnits::IsLeap(int y) { |
| | | return ((y % 4 == 0) && (y % 100 != 0)) || (y % 400 == 0); |
| | | } |
| | | |
| | | int CToolUnits::DaysInMonth(int y, int m) { |
| | | static const int d[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 }; |
| | | return (m == 2) ? d[m] + (IsLeap(y) ? 1 : 0) : d[m]; |
| | | } |
| | | |
| | | // æ¬å°âä»å¤©âçå¹´ææ¥ |
| | | void CToolUnits::GetTodayYMD_Local(int& y, int& m, int& d) { |
| | | SYSTEMTIME now{}; GetLocalTime(&now); |
| | | y = now.wYear; m = now.wMonth; d = now.wDay; |
| | | } |
| | | |
| | | // æ¬å°æ¥åä¸å n 天ï¼ä»æ¯æ¬å° Y/M/Dï¼ |
| | | void CToolUnits::LocalCalendarMinusDays(int& y, int& m, int& d, int nDays) { |
| | | std::tm t{}; |
| | | t.tm_year = y - 1900; t.tm_mon = m - 1; t.tm_mday = d; |
| | | t.tm_hour = 0; t.tm_min = 0; t.tm_sec = 0; |
| | | t.tm_mday -= nDays; |
| | | (void)std::mktime(&t); // ææ¬å°æ¶åºå½ä¸å |
| | | y = t.tm_year + 1900; m = t.tm_mon + 1; d = t.tm_mday; |
| | | } |
| | | |
| | | // ====== æ ¸å¿ï¼è®¡ç®é¢è®¾åºé´ç UTC [from, to] ====== |
| | | // è¯ä¹ï¼ |
| | | // - Today : æ¬å°âä»å¤©â00:00:00.000 ï½ ä»å¤© 23:59:59.999 |
| | | // - Last7Days : æ¬å°â6 天åâ00:00:00.000 ï½ ä»å¤© 23:59:59.999ï¼å
± 7 个èªç¶æ¥ï¼å«ä»å¤©ï¼ |
| | | // - ThisMonth : æ¬å°â彿 1 å·â00:00:00.000 ï½ æ¬ææ« 23:59:59.999 |
| | | // - ThisYear : æ¬å°âå½å¹´ 1/1â00:00:00.000 ï½ å½å¹´æ« 23:59:59.999 |
| | | std::pair<std::chrono::system_clock::time_point, |
| | | std::chrono::system_clock::time_point> |
| | | CToolUnits::CalcQuickRangeUtc(QuickRange r) |
| | | { |
| | | int y, m, d; |
| | | GetTodayYMD_Local(y, m, d); |
| | | |
| | | SYSTEMTIME stFromLocal{}, stToLocal{}; |
| | | |
| | | switch (r) { |
| | | case QuickRange::Today: |
| | | stFromLocal = MakeLocalST(y, m, d, 0, 0, 0, 0); |
| | | stToLocal = MakeLocalST(y, m, d, 23, 59, 59, 999); |
| | | break; |
| | | case QuickRange::Last7Days: { |
| | | int y2 = y, m2 = m, d2 = d; |
| | | LocalCalendarMinusDays(y2, m2, d2, 6); |
| | | stFromLocal = MakeLocalST(y2, m2, d2, 0, 0, 0, 0); |
| | | stToLocal = MakeLocalST(y, m, d, 23, 59, 59, 999); |
| | | break; |
| | | } |
| | | case QuickRange::ThisMonth: { |
| | | int lastDay = DaysInMonth(y, m); |
| | | stFromLocal = MakeLocalST(y, m, 1, 0, 0, 0, 0); |
| | | stToLocal = MakeLocalST(y, m, lastDay, 23, 59, 59, 999); |
| | | break; |
| | | } |
| | | case QuickRange::ThisYear: |
| | | stFromLocal = MakeLocalST(y, 1, 1, 0, 0, 0, 0); |
| | | stToLocal = MakeLocalST(y, 12, DaysInMonth(y, 12), 23, 59, 59, 999); |
| | | break; |
| | | default: |
| | | throw std::invalid_argument("CalcQuickRangeUtc: unsupported range"); |
| | | } |
| | | |
| | | auto fromUtc = LocalSTtoUtcTP(stFromLocal); |
| | | auto toUtc = LocalSTtoUtcTP(stToLocal); |
| | | return { fromUtc, toUtc }; |
| | | } |
| | | |
| | | // å°å·¥å
·ï¼ASCII ä¸åºå大å°åå
å«ï¼ä¸æçé ASCII ä¸åå½±åï¼ä½ä¹ä¸éè¦å¤§å°å转æ¢ï¼ |
| | | bool CToolUnits::containsCI(const std::string& hay, const std::string& needle) { |
| | | if (needle.empty()) return true; |
| | | auto toLower = [](std::string s) { std::transform(s.begin(), s.end(), s.begin(), |
| | | [](unsigned char c) { return (char)std::tolower(c); }); return s; }; |
| | | std::string h = toLower(hay), n = toLower(needle); |
| | | return h.find(n) != std::string::npos; |
| | | } |
| | | |
| | | // ------- æ¬å°æ¶é´ ------- |
| | | std::string CToolUnits::TimePointToLocalString(const std::optional<TP>& tp, |
| | | const char* fmt/* = "%Y-%m-%d %H:%M:%S"*/) |
| | | { |
| | | if (!tp) return {}; |
| | | std::time_t t = std::chrono::system_clock::to_time_t(*tp); |
| | | std::tm tm{}; |
| | | #if defined(_WIN32) |
| | | localtime_s(&tm, &t); |
| | | #else |
| | | localtime_r(&t, &tm); |
| | | #endif |
| | | char buf[64]{}; |
| | | std::strftime(buf, sizeof(buf), fmt, &tm); |
| | | return buf; |
| | | } |
| | | |
| | | // ------- UTC æ¶é´ ------- |
| | | std::string CToolUnits::TimePointToUtcString(const std::optional<TP>& tp, |
| | | const char* fmt/* = "%Y-%m-%d %H:%M:%S"*/) |
| | | { |
| | | if (!tp) return {}; |
| | | std::time_t t = std::chrono::system_clock::to_time_t(*tp); |
| | | std::tm tm{}; |
| | | #if defined(_WIN32) |
| | | gmtime_s(&tm, &t); |
| | | #else |
| | | gmtime_r(&t, &tm); |
| | | #endif |
| | | char buf[64]{}; |
| | | std::strftime(buf, sizeof(buf), fmt, &tm); |
| | | return buf; |
| | | } |
| | | |
| | | std::string CToolUnits::TimePointToLocalStringMs(const std::optional<TP>& tp) |
| | | { |
| | | if (!tp) return {}; |
| | | using namespace std::chrono; |
| | | auto ms_since_epoch = duration_cast<milliseconds>(tp->time_since_epoch()); |
| | | auto ms = static_cast<int>(ms_since_epoch.count() % 1000); |
| | | |
| | | std::time_t t = system_clock::to_time_t(*tp); |
| | | std::tm tm{}; |
| | | #if defined(_WIN32) |
| | | localtime_s(&tm, &t); |
| | | #else |
| | | localtime_r(&t, &tm); |
| | | #endif |
| | | char date[32]{}; |
| | | std::strftime(date, sizeof(date), "%Y-%m-%d %H:%M:%S", &tm); |
| | | |
| | | char out[40]{}; |
| | | std::snprintf(out, sizeof(out), "%s.%03d", date, ms); |
| | | return out; |
| | | } |
| | |
| | | #pragma once |
| | | #include <string> |
| | | #include <chrono> |
| | | #include <optional> |
| | | #include <utility> |
| | | |
| | | enum class QuickRange { Today, Last7Days, ThisMonth, ThisYear }; |
| | | using TP = std::chrono::system_clock::time_point; |
| | | class CToolUnits |
| | | { |
| | | public: |
| | |
| | | static bool startsWith(const std::string& str, const std::string& prefix); |
| | | static std::string& toHexString(int value, std::string& strOut); |
| | | static void convertString(const char* pszBuffer, int size, std::string& strOut); |
| | | static inline std::chrono::system_clock::time_point FileTimeToTimePointUTC(const FILETIME& ftUtc); |
| | | static bool GetCtrlTimeUtc(const CDateTimeCtrl& ctrl, |
| | | std::chrono::system_clock::time_point& outUtc); |
| | | static bool GetCtrlDateRangeUtc_StartOfDay(const CDateTimeCtrl& ctrl, |
| | | std::chrono::system_clock::time_point& outUtc); |
| | | static bool GetCtrlDateRangeUtc_EndOfDay(const CDateTimeCtrl& ctrl, |
| | | std::chrono::system_clock::time_point& outUtc); |
| | | static std::chrono::system_clock::time_point CToolUnits::LocalSTtoUtcTP(const SYSTEMTIME& stLocal); |
| | | static SYSTEMTIME CToolUnits::MakeLocalST(int y, int m, int d, int hh, int mi, int ss, int ms); |
| | | static bool IsLeap(int y); |
| | | static int DaysInMonth(int y, int m); |
| | | static void GetTodayYMD_Local(int& y, int& m, int& d); |
| | | static void LocalCalendarMinusDays(int& y, int& m, int& d, int nDays); |
| | | static std::pair<std::chrono::system_clock::time_point, |
| | | std::chrono::system_clock::time_point> |
| | | CalcQuickRangeUtc(QuickRange r); |
| | | static bool containsCI(const std::string& hay, const std::string& needle); |
| | | static std::string TimePointToLocalString(const std::optional<TP>& tp, |
| | | const char* fmt = "%Y-%m-%d %H:%M:%S"); |
| | | static std::string TimePointToUtcString(const std::optional<TP>& tp, |
| | | const char* fmt = "%Y-%m-%d %H:%M:%S"); |
| | | static std::string TimePointToLocalStringMs(const std::optional<TP>& tp); |
| | | }; |
| | | |
| ¶Ô±ÈÐÂÎļþ |
| | |
| | | /* |
| | | ** 2006 June 7 |
| | | ** |
| | | ** The author disclaims copyright to this source code. In place of |
| | | ** a legal notice, here is a blessing: |
| | | ** |
| | | ** May you do good and not evil. |
| | | ** May you find forgiveness for yourself and forgive others. |
| | | ** May you share freely, never taking more than you give. |
| | | ** |
| | | ************************************************************************* |
| | | ** This header file defines the SQLite interface for use by |
| | | ** shared libraries that want to be imported as extensions into |
| | | ** an SQLite instance. Shared libraries that intend to be loaded |
| | | ** as extensions by SQLite should #include this file instead of |
| | | ** sqlite3.h. |
| | | */ |
| | | #ifndef SQLITE3EXT_H |
| | | #define SQLITE3EXT_H |
| | | #include "sqlite3.h" |
| | | |
| | | /* |
| | | ** The following structure holds pointers to all of the SQLite API |
| | | ** routines. |
| | | ** |
| | | ** WARNING: In order to maintain backwards compatibility, add new |
| | | ** interfaces to the end of this structure only. If you insert new |
| | | ** interfaces in the middle of this structure, then older different |
| | | ** versions of SQLite will not be able to load each other's shared |
| | | ** libraries! |
| | | */ |
| | | struct sqlite3_api_routines { |
| | | void * (*aggregate_context)(sqlite3_context*,int nBytes); |
| | | int (*aggregate_count)(sqlite3_context*); |
| | | int (*bind_blob)(sqlite3_stmt*,int,const void*,int n,void(*)(void*)); |
| | | int (*bind_double)(sqlite3_stmt*,int,double); |
| | | int (*bind_int)(sqlite3_stmt*,int,int); |
| | | int (*bind_int64)(sqlite3_stmt*,int,sqlite_int64); |
| | | int (*bind_null)(sqlite3_stmt*,int); |
| | | int (*bind_parameter_count)(sqlite3_stmt*); |
| | | int (*bind_parameter_index)(sqlite3_stmt*,const char*zName); |
| | | const char * (*bind_parameter_name)(sqlite3_stmt*,int); |
| | | int (*bind_text)(sqlite3_stmt*,int,const char*,int n,void(*)(void*)); |
| | | int (*bind_text16)(sqlite3_stmt*,int,const void*,int,void(*)(void*)); |
| | | int (*bind_value)(sqlite3_stmt*,int,const sqlite3_value*); |
| | | int (*busy_handler)(sqlite3*,int(*)(void*,int),void*); |
| | | int (*busy_timeout)(sqlite3*,int ms); |
| | | int (*changes)(sqlite3*); |
| | | int (*close)(sqlite3*); |
| | | int (*collation_needed)(sqlite3*,void*,void(*)(void*,sqlite3*, |
| | | int eTextRep,const char*)); |
| | | int (*collation_needed16)(sqlite3*,void*,void(*)(void*,sqlite3*, |
| | | int eTextRep,const void*)); |
| | | const void * (*column_blob)(sqlite3_stmt*,int iCol); |
| | | int (*column_bytes)(sqlite3_stmt*,int iCol); |
| | | int (*column_bytes16)(sqlite3_stmt*,int iCol); |
| | | int (*column_count)(sqlite3_stmt*pStmt); |
| | | const char * (*column_database_name)(sqlite3_stmt*,int); |
| | | const void * (*column_database_name16)(sqlite3_stmt*,int); |
| | | const char * (*column_decltype)(sqlite3_stmt*,int i); |
| | | const void * (*column_decltype16)(sqlite3_stmt*,int); |
| | | double (*column_double)(sqlite3_stmt*,int iCol); |
| | | int (*column_int)(sqlite3_stmt*,int iCol); |
| | | sqlite_int64 (*column_int64)(sqlite3_stmt*,int iCol); |
| | | const char * (*column_name)(sqlite3_stmt*,int); |
| | | const void * (*column_name16)(sqlite3_stmt*,int); |
| | | const char * (*column_origin_name)(sqlite3_stmt*,int); |
| | | const void * (*column_origin_name16)(sqlite3_stmt*,int); |
| | | const char * (*column_table_name)(sqlite3_stmt*,int); |
| | | const void * (*column_table_name16)(sqlite3_stmt*,int); |
| | | const unsigned char * (*column_text)(sqlite3_stmt*,int iCol); |
| | | const void * (*column_text16)(sqlite3_stmt*,int iCol); |
| | | int (*column_type)(sqlite3_stmt*,int iCol); |
| | | sqlite3_value* (*column_value)(sqlite3_stmt*,int iCol); |
| | | void * (*commit_hook)(sqlite3*,int(*)(void*),void*); |
| | | int (*complete)(const char*sql); |
| | | int (*complete16)(const void*sql); |
| | | int (*create_collation)(sqlite3*,const char*,int,void*, |
| | | int(*)(void*,int,const void*,int,const void*)); |
| | | int (*create_collation16)(sqlite3*,const void*,int,void*, |
| | | int(*)(void*,int,const void*,int,const void*)); |
| | | int (*create_function)(sqlite3*,const char*,int,int,void*, |
| | | void (*xFunc)(sqlite3_context*,int,sqlite3_value**), |
| | | void (*xStep)(sqlite3_context*,int,sqlite3_value**), |
| | | void (*xFinal)(sqlite3_context*)); |
| | | int (*create_function16)(sqlite3*,const void*,int,int,void*, |
| | | void (*xFunc)(sqlite3_context*,int,sqlite3_value**), |
| | | void (*xStep)(sqlite3_context*,int,sqlite3_value**), |
| | | void (*xFinal)(sqlite3_context*)); |
| | | int (*create_module)(sqlite3*,const char*,const sqlite3_module*,void*); |
| | | int (*data_count)(sqlite3_stmt*pStmt); |
| | | sqlite3 * (*db_handle)(sqlite3_stmt*); |
| | | int (*declare_vtab)(sqlite3*,const char*); |
| | | int (*enable_shared_cache)(int); |
| | | int (*errcode)(sqlite3*db); |
| | | const char * (*errmsg)(sqlite3*); |
| | | const void * (*errmsg16)(sqlite3*); |
| | | int (*exec)(sqlite3*,const char*,sqlite3_callback,void*,char**); |
| | | int (*expired)(sqlite3_stmt*); |
| | | int (*finalize)(sqlite3_stmt*pStmt); |
| | | void (*free)(void*); |
| | | void (*free_table)(char**result); |
| | | int (*get_autocommit)(sqlite3*); |
| | | void * (*get_auxdata)(sqlite3_context*,int); |
| | | int (*get_table)(sqlite3*,const char*,char***,int*,int*,char**); |
| | | int (*global_recover)(void); |
| | | void (*interruptx)(sqlite3*); |
| | | sqlite_int64 (*last_insert_rowid)(sqlite3*); |
| | | const char * (*libversion)(void); |
| | | int (*libversion_number)(void); |
| | | void *(*malloc)(int); |
| | | char * (*mprintf)(const char*,...); |
| | | int (*open)(const char*,sqlite3**); |
| | | int (*open16)(const void*,sqlite3**); |
| | | int (*prepare)(sqlite3*,const char*,int,sqlite3_stmt**,const char**); |
| | | int (*prepare16)(sqlite3*,const void*,int,sqlite3_stmt**,const void**); |
| | | void * (*profile)(sqlite3*,void(*)(void*,const char*,sqlite_uint64),void*); |
| | | void (*progress_handler)(sqlite3*,int,int(*)(void*),void*); |
| | | void *(*realloc)(void*,int); |
| | | int (*reset)(sqlite3_stmt*pStmt); |
| | | void (*result_blob)(sqlite3_context*,const void*,int,void(*)(void*)); |
| | | void (*result_double)(sqlite3_context*,double); |
| | | void (*result_error)(sqlite3_context*,const char*,int); |
| | | void (*result_error16)(sqlite3_context*,const void*,int); |
| | | void (*result_int)(sqlite3_context*,int); |
| | | void (*result_int64)(sqlite3_context*,sqlite_int64); |
| | | void (*result_null)(sqlite3_context*); |
| | | void (*result_text)(sqlite3_context*,const char*,int,void(*)(void*)); |
| | | void (*result_text16)(sqlite3_context*,const void*,int,void(*)(void*)); |
| | | void (*result_text16be)(sqlite3_context*,const void*,int,void(*)(void*)); |
| | | void (*result_text16le)(sqlite3_context*,const void*,int,void(*)(void*)); |
| | | void (*result_value)(sqlite3_context*,sqlite3_value*); |
| | | void * (*rollback_hook)(sqlite3*,void(*)(void*),void*); |
| | | int (*set_authorizer)(sqlite3*,int(*)(void*,int,const char*,const char*, |
| | | const char*,const char*),void*); |
| | | void (*set_auxdata)(sqlite3_context*,int,void*,void (*)(void*)); |
| | | char * (*xsnprintf)(int,char*,const char*,...); |
| | | int (*step)(sqlite3_stmt*); |
| | | int (*table_column_metadata)(sqlite3*,const char*,const char*,const char*, |
| | | char const**,char const**,int*,int*,int*); |
| | | void (*thread_cleanup)(void); |
| | | int (*total_changes)(sqlite3*); |
| | | void * (*trace)(sqlite3*,void(*xTrace)(void*,const char*),void*); |
| | | int (*transfer_bindings)(sqlite3_stmt*,sqlite3_stmt*); |
| | | void * (*update_hook)(sqlite3*,void(*)(void*,int ,char const*,char const*, |
| | | sqlite_int64),void*); |
| | | void * (*user_data)(sqlite3_context*); |
| | | const void * (*value_blob)(sqlite3_value*); |
| | | int (*value_bytes)(sqlite3_value*); |
| | | int (*value_bytes16)(sqlite3_value*); |
| | | double (*value_double)(sqlite3_value*); |
| | | int (*value_int)(sqlite3_value*); |
| | | sqlite_int64 (*value_int64)(sqlite3_value*); |
| | | int (*value_numeric_type)(sqlite3_value*); |
| | | const unsigned char * (*value_text)(sqlite3_value*); |
| | | const void * (*value_text16)(sqlite3_value*); |
| | | const void * (*value_text16be)(sqlite3_value*); |
| | | const void * (*value_text16le)(sqlite3_value*); |
| | | int (*value_type)(sqlite3_value*); |
| | | char *(*vmprintf)(const char*,va_list); |
| | | /* Added ??? */ |
| | | int (*overload_function)(sqlite3*, const char *zFuncName, int nArg); |
| | | /* Added by 3.3.13 */ |
| | | int (*prepare_v2)(sqlite3*,const char*,int,sqlite3_stmt**,const char**); |
| | | int (*prepare16_v2)(sqlite3*,const void*,int,sqlite3_stmt**,const void**); |
| | | int (*clear_bindings)(sqlite3_stmt*); |
| | | /* Added by 3.4.1 */ |
| | | int (*create_module_v2)(sqlite3*,const char*,const sqlite3_module*,void*, |
| | | void (*xDestroy)(void *)); |
| | | /* Added by 3.5.0 */ |
| | | int (*bind_zeroblob)(sqlite3_stmt*,int,int); |
| | | int (*blob_bytes)(sqlite3_blob*); |
| | | int (*blob_close)(sqlite3_blob*); |
| | | int (*blob_open)(sqlite3*,const char*,const char*,const char*,sqlite3_int64, |
| | | int,sqlite3_blob**); |
| | | int (*blob_read)(sqlite3_blob*,void*,int,int); |
| | | int (*blob_write)(sqlite3_blob*,const void*,int,int); |
| | | int (*create_collation_v2)(sqlite3*,const char*,int,void*, |
| | | int(*)(void*,int,const void*,int,const void*), |
| | | void(*)(void*)); |
| | | int (*file_control)(sqlite3*,const char*,int,void*); |
| | | sqlite3_int64 (*memory_highwater)(int); |
| | | sqlite3_int64 (*memory_used)(void); |
| | | sqlite3_mutex *(*mutex_alloc)(int); |
| | | void (*mutex_enter)(sqlite3_mutex*); |
| | | void (*mutex_free)(sqlite3_mutex*); |
| | | void (*mutex_leave)(sqlite3_mutex*); |
| | | int (*mutex_try)(sqlite3_mutex*); |
| | | int (*open_v2)(const char*,sqlite3**,int,const char*); |
| | | int (*release_memory)(int); |
| | | void (*result_error_nomem)(sqlite3_context*); |
| | | void (*result_error_toobig)(sqlite3_context*); |
| | | int (*sleep)(int); |
| | | void (*soft_heap_limit)(int); |
| | | sqlite3_vfs *(*vfs_find)(const char*); |
| | | int (*vfs_register)(sqlite3_vfs*,int); |
| | | int (*vfs_unregister)(sqlite3_vfs*); |
| | | int (*xthreadsafe)(void); |
| | | void (*result_zeroblob)(sqlite3_context*,int); |
| | | void (*result_error_code)(sqlite3_context*,int); |
| | | int (*test_control)(int, ...); |
| | | void (*randomness)(int,void*); |
| | | sqlite3 *(*context_db_handle)(sqlite3_context*); |
| | | int (*extended_result_codes)(sqlite3*,int); |
| | | int (*limit)(sqlite3*,int,int); |
| | | sqlite3_stmt *(*next_stmt)(sqlite3*,sqlite3_stmt*); |
| | | const char *(*sql)(sqlite3_stmt*); |
| | | int (*status)(int,int*,int*,int); |
| | | int (*backup_finish)(sqlite3_backup*); |
| | | sqlite3_backup *(*backup_init)(sqlite3*,const char*,sqlite3*,const char*); |
| | | int (*backup_pagecount)(sqlite3_backup*); |
| | | int (*backup_remaining)(sqlite3_backup*); |
| | | int (*backup_step)(sqlite3_backup*,int); |
| | | const char *(*compileoption_get)(int); |
| | | int (*compileoption_used)(const char*); |
| | | int (*create_function_v2)(sqlite3*,const char*,int,int,void*, |
| | | void (*xFunc)(sqlite3_context*,int,sqlite3_value**), |
| | | void (*xStep)(sqlite3_context*,int,sqlite3_value**), |
| | | void (*xFinal)(sqlite3_context*), |
| | | void(*xDestroy)(void*)); |
| | | int (*db_config)(sqlite3*,int,...); |
| | | sqlite3_mutex *(*db_mutex)(sqlite3*); |
| | | int (*db_status)(sqlite3*,int,int*,int*,int); |
| | | int (*extended_errcode)(sqlite3*); |
| | | void (*log)(int,const char*,...); |
| | | sqlite3_int64 (*soft_heap_limit64)(sqlite3_int64); |
| | | const char *(*sourceid)(void); |
| | | int (*stmt_status)(sqlite3_stmt*,int,int); |
| | | int (*strnicmp)(const char*,const char*,int); |
| | | int (*unlock_notify)(sqlite3*,void(*)(void**,int),void*); |
| | | int (*wal_autocheckpoint)(sqlite3*,int); |
| | | int (*wal_checkpoint)(sqlite3*,const char*); |
| | | void *(*wal_hook)(sqlite3*,int(*)(void*,sqlite3*,const char*,int),void*); |
| | | int (*blob_reopen)(sqlite3_blob*,sqlite3_int64); |
| | | int (*vtab_config)(sqlite3*,int op,...); |
| | | int (*vtab_on_conflict)(sqlite3*); |
| | | /* Version 3.7.16 and later */ |
| | | int (*close_v2)(sqlite3*); |
| | | const char *(*db_filename)(sqlite3*,const char*); |
| | | int (*db_readonly)(sqlite3*,const char*); |
| | | int (*db_release_memory)(sqlite3*); |
| | | const char *(*errstr)(int); |
| | | int (*stmt_busy)(sqlite3_stmt*); |
| | | int (*stmt_readonly)(sqlite3_stmt*); |
| | | int (*stricmp)(const char*,const char*); |
| | | int (*uri_boolean)(const char*,const char*,int); |
| | | sqlite3_int64 (*uri_int64)(const char*,const char*,sqlite3_int64); |
| | | const char *(*uri_parameter)(const char*,const char*); |
| | | char *(*xvsnprintf)(int,char*,const char*,va_list); |
| | | int (*wal_checkpoint_v2)(sqlite3*,const char*,int,int*,int*); |
| | | /* Version 3.8.7 and later */ |
| | | int (*auto_extension)(void(*)(void)); |
| | | int (*bind_blob64)(sqlite3_stmt*,int,const void*,sqlite3_uint64, |
| | | void(*)(void*)); |
| | | int (*bind_text64)(sqlite3_stmt*,int,const char*,sqlite3_uint64, |
| | | void(*)(void*),unsigned char); |
| | | int (*cancel_auto_extension)(void(*)(void)); |
| | | int (*load_extension)(sqlite3*,const char*,const char*,char**); |
| | | void *(*malloc64)(sqlite3_uint64); |
| | | sqlite3_uint64 (*msize)(void*); |
| | | void *(*realloc64)(void*,sqlite3_uint64); |
| | | void (*reset_auto_extension)(void); |
| | | void (*result_blob64)(sqlite3_context*,const void*,sqlite3_uint64, |
| | | void(*)(void*)); |
| | | void (*result_text64)(sqlite3_context*,const char*,sqlite3_uint64, |
| | | void(*)(void*), unsigned char); |
| | | int (*strglob)(const char*,const char*); |
| | | /* Version 3.8.11 and later */ |
| | | sqlite3_value *(*value_dup)(const sqlite3_value*); |
| | | void (*value_free)(sqlite3_value*); |
| | | int (*result_zeroblob64)(sqlite3_context*,sqlite3_uint64); |
| | | int (*bind_zeroblob64)(sqlite3_stmt*, int, sqlite3_uint64); |
| | | /* Version 3.9.0 and later */ |
| | | unsigned int (*value_subtype)(sqlite3_value*); |
| | | void (*result_subtype)(sqlite3_context*,unsigned int); |
| | | /* Version 3.10.0 and later */ |
| | | int (*status64)(int,sqlite3_int64*,sqlite3_int64*,int); |
| | | int (*strlike)(const char*,const char*,unsigned int); |
| | | int (*db_cacheflush)(sqlite3*); |
| | | /* Version 3.12.0 and later */ |
| | | int (*system_errno)(sqlite3*); |
| | | /* Version 3.14.0 and later */ |
| | | int (*trace_v2)(sqlite3*,unsigned,int(*)(unsigned,void*,void*,void*),void*); |
| | | char *(*expanded_sql)(sqlite3_stmt*); |
| | | /* Version 3.18.0 and later */ |
| | | void (*set_last_insert_rowid)(sqlite3*,sqlite3_int64); |
| | | /* Version 3.20.0 and later */ |
| | | int (*prepare_v3)(sqlite3*,const char*,int,unsigned int, |
| | | sqlite3_stmt**,const char**); |
| | | int (*prepare16_v3)(sqlite3*,const void*,int,unsigned int, |
| | | sqlite3_stmt**,const void**); |
| | | int (*bind_pointer)(sqlite3_stmt*,int,void*,const char*,void(*)(void*)); |
| | | void (*result_pointer)(sqlite3_context*,void*,const char*,void(*)(void*)); |
| | | void *(*value_pointer)(sqlite3_value*,const char*); |
| | | int (*vtab_nochange)(sqlite3_context*); |
| | | int (*value_nochange)(sqlite3_value*); |
| | | const char *(*vtab_collation)(sqlite3_index_info*,int); |
| | | /* Version 3.24.0 and later */ |
| | | int (*keyword_count)(void); |
| | | int (*keyword_name)(int,const char**,int*); |
| | | int (*keyword_check)(const char*,int); |
| | | sqlite3_str *(*str_new)(sqlite3*); |
| | | char *(*str_finish)(sqlite3_str*); |
| | | void (*str_appendf)(sqlite3_str*, const char *zFormat, ...); |
| | | void (*str_vappendf)(sqlite3_str*, const char *zFormat, va_list); |
| | | void (*str_append)(sqlite3_str*, const char *zIn, int N); |
| | | void (*str_appendall)(sqlite3_str*, const char *zIn); |
| | | void (*str_appendchar)(sqlite3_str*, int N, char C); |
| | | void (*str_reset)(sqlite3_str*); |
| | | int (*str_errcode)(sqlite3_str*); |
| | | int (*str_length)(sqlite3_str*); |
| | | char *(*str_value)(sqlite3_str*); |
| | | /* Version 3.25.0 and later */ |
| | | int (*create_window_function)(sqlite3*,const char*,int,int,void*, |
| | | void (*xStep)(sqlite3_context*,int,sqlite3_value**), |
| | | void (*xFinal)(sqlite3_context*), |
| | | void (*xValue)(sqlite3_context*), |
| | | void (*xInv)(sqlite3_context*,int,sqlite3_value**), |
| | | void(*xDestroy)(void*)); |
| | | /* Version 3.26.0 and later */ |
| | | const char *(*normalized_sql)(sqlite3_stmt*); |
| | | /* Version 3.28.0 and later */ |
| | | int (*stmt_isexplain)(sqlite3_stmt*); |
| | | int (*value_frombind)(sqlite3_value*); |
| | | /* Version 3.30.0 and later */ |
| | | int (*drop_modules)(sqlite3*,const char**); |
| | | /* Version 3.31.0 and later */ |
| | | sqlite3_int64 (*hard_heap_limit64)(sqlite3_int64); |
| | | const char *(*uri_key)(const char*,int); |
| | | const char *(*filename_database)(const char*); |
| | | const char *(*filename_journal)(const char*); |
| | | const char *(*filename_wal)(const char*); |
| | | /* Version 3.32.0 and later */ |
| | | const char *(*create_filename)(const char*,const char*,const char*, |
| | | int,const char**); |
| | | void (*free_filename)(const char*); |
| | | sqlite3_file *(*database_file_object)(const char*); |
| | | /* Version 3.34.0 and later */ |
| | | int (*txn_state)(sqlite3*,const char*); |
| | | /* Version 3.36.1 and later */ |
| | | sqlite3_int64 (*changes64)(sqlite3*); |
| | | sqlite3_int64 (*total_changes64)(sqlite3*); |
| | | /* Version 3.37.0 and later */ |
| | | int (*autovacuum_pages)(sqlite3*, |
| | | unsigned int(*)(void*,const char*,unsigned int,unsigned int,unsigned int), |
| | | void*, void(*)(void*)); |
| | | /* Version 3.38.0 and later */ |
| | | int (*error_offset)(sqlite3*); |
| | | int (*vtab_rhs_value)(sqlite3_index_info*,int,sqlite3_value**); |
| | | int (*vtab_distinct)(sqlite3_index_info*); |
| | | int (*vtab_in)(sqlite3_index_info*,int,int); |
| | | int (*vtab_in_first)(sqlite3_value*,sqlite3_value**); |
| | | int (*vtab_in_next)(sqlite3_value*,sqlite3_value**); |
| | | /* Version 3.39.0 and later */ |
| | | int (*deserialize)(sqlite3*,const char*,unsigned char*, |
| | | sqlite3_int64,sqlite3_int64,unsigned); |
| | | unsigned char *(*serialize)(sqlite3*,const char *,sqlite3_int64*, |
| | | unsigned int); |
| | | const char *(*db_name)(sqlite3*,int); |
| | | /* Version 3.40.0 and later */ |
| | | int (*value_encoding)(sqlite3_value*); |
| | | /* Version 3.41.0 and later */ |
| | | int (*is_interrupted)(sqlite3*); |
| | | /* Version 3.43.0 and later */ |
| | | int (*stmt_explain)(sqlite3_stmt*,int); |
| | | /* Version 3.44.0 and later */ |
| | | void *(*get_clientdata)(sqlite3*,const char*); |
| | | int (*set_clientdata)(sqlite3*, const char*, void*, void(*)(void*)); |
| | | }; |
| | | |
| | | /* |
| | | ** This is the function signature used for all extension entry points. It |
| | | ** is also defined in the file "loadext.c". |
| | | */ |
| | | typedef int (*sqlite3_loadext_entry)( |
| | | sqlite3 *db, /* Handle to the database. */ |
| | | char **pzErrMsg, /* Used to set error string on failure. */ |
| | | const sqlite3_api_routines *pThunk /* Extension API function pointers. */ |
| | | ); |
| | | |
| | | /* |
| | | ** The following macros redefine the API routines so that they are |
| | | ** redirected through the global sqlite3_api structure. |
| | | ** |
| | | ** This header file is also used by the loadext.c source file |
| | | ** (part of the main SQLite library - not an extension) so that |
| | | ** it can get access to the sqlite3_api_routines structure |
| | | ** definition. But the main library does not want to redefine |
| | | ** the API. So the redefinition macros are only valid if the |
| | | ** SQLITE_CORE macros is undefined. |
| | | */ |
| | | #if !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION) |
| | | #define sqlite3_aggregate_context sqlite3_api->aggregate_context |
| | | #ifndef SQLITE_OMIT_DEPRECATED |
| | | #define sqlite3_aggregate_count sqlite3_api->aggregate_count |
| | | #endif |
| | | #define sqlite3_bind_blob sqlite3_api->bind_blob |
| | | #define sqlite3_bind_double sqlite3_api->bind_double |
| | | #define sqlite3_bind_int sqlite3_api->bind_int |
| | | #define sqlite3_bind_int64 sqlite3_api->bind_int64 |
| | | #define sqlite3_bind_null sqlite3_api->bind_null |
| | | #define sqlite3_bind_parameter_count sqlite3_api->bind_parameter_count |
| | | #define sqlite3_bind_parameter_index sqlite3_api->bind_parameter_index |
| | | #define sqlite3_bind_parameter_name sqlite3_api->bind_parameter_name |
| | | #define sqlite3_bind_text sqlite3_api->bind_text |
| | | #define sqlite3_bind_text16 sqlite3_api->bind_text16 |
| | | #define sqlite3_bind_value sqlite3_api->bind_value |
| | | #define sqlite3_busy_handler sqlite3_api->busy_handler |
| | | #define sqlite3_busy_timeout sqlite3_api->busy_timeout |
| | | #define sqlite3_changes sqlite3_api->changes |
| | | #define sqlite3_close sqlite3_api->close |
| | | #define sqlite3_collation_needed sqlite3_api->collation_needed |
| | | #define sqlite3_collation_needed16 sqlite3_api->collation_needed16 |
| | | #define sqlite3_column_blob sqlite3_api->column_blob |
| | | #define sqlite3_column_bytes sqlite3_api->column_bytes |
| | | #define sqlite3_column_bytes16 sqlite3_api->column_bytes16 |
| | | #define sqlite3_column_count sqlite3_api->column_count |
| | | #define sqlite3_column_database_name sqlite3_api->column_database_name |
| | | #define sqlite3_column_database_name16 sqlite3_api->column_database_name16 |
| | | #define sqlite3_column_decltype sqlite3_api->column_decltype |
| | | #define sqlite3_column_decltype16 sqlite3_api->column_decltype16 |
| | | #define sqlite3_column_double sqlite3_api->column_double |
| | | #define sqlite3_column_int sqlite3_api->column_int |
| | | #define sqlite3_column_int64 sqlite3_api->column_int64 |
| | | #define sqlite3_column_name sqlite3_api->column_name |
| | | #define sqlite3_column_name16 sqlite3_api->column_name16 |
| | | #define sqlite3_column_origin_name sqlite3_api->column_origin_name |
| | | #define sqlite3_column_origin_name16 sqlite3_api->column_origin_name16 |
| | | #define sqlite3_column_table_name sqlite3_api->column_table_name |
| | | #define sqlite3_column_table_name16 sqlite3_api->column_table_name16 |
| | | #define sqlite3_column_text sqlite3_api->column_text |
| | | #define sqlite3_column_text16 sqlite3_api->column_text16 |
| | | #define sqlite3_column_type sqlite3_api->column_type |
| | | #define sqlite3_column_value sqlite3_api->column_value |
| | | #define sqlite3_commit_hook sqlite3_api->commit_hook |
| | | #define sqlite3_complete sqlite3_api->complete |
| | | #define sqlite3_complete16 sqlite3_api->complete16 |
| | | #define sqlite3_create_collation sqlite3_api->create_collation |
| | | #define sqlite3_create_collation16 sqlite3_api->create_collation16 |
| | | #define sqlite3_create_function sqlite3_api->create_function |
| | | #define sqlite3_create_function16 sqlite3_api->create_function16 |
| | | #define sqlite3_create_module sqlite3_api->create_module |
| | | #define sqlite3_create_module_v2 sqlite3_api->create_module_v2 |
| | | #define sqlite3_data_count sqlite3_api->data_count |
| | | #define sqlite3_db_handle sqlite3_api->db_handle |
| | | #define sqlite3_declare_vtab sqlite3_api->declare_vtab |
| | | #define sqlite3_enable_shared_cache sqlite3_api->enable_shared_cache |
| | | #define sqlite3_errcode sqlite3_api->errcode |
| | | #define sqlite3_errmsg sqlite3_api->errmsg |
| | | #define sqlite3_errmsg16 sqlite3_api->errmsg16 |
| | | #define sqlite3_exec sqlite3_api->exec |
| | | #ifndef SQLITE_OMIT_DEPRECATED |
| | | #define sqlite3_expired sqlite3_api->expired |
| | | #endif |
| | | #define sqlite3_finalize sqlite3_api->finalize |
| | | #define sqlite3_free sqlite3_api->free |
| | | #define sqlite3_free_table sqlite3_api->free_table |
| | | #define sqlite3_get_autocommit sqlite3_api->get_autocommit |
| | | #define sqlite3_get_auxdata sqlite3_api->get_auxdata |
| | | #define sqlite3_get_table sqlite3_api->get_table |
| | | #ifndef SQLITE_OMIT_DEPRECATED |
| | | #define sqlite3_global_recover sqlite3_api->global_recover |
| | | #endif |
| | | #define sqlite3_interrupt sqlite3_api->interruptx |
| | | #define sqlite3_last_insert_rowid sqlite3_api->last_insert_rowid |
| | | #define sqlite3_libversion sqlite3_api->libversion |
| | | #define sqlite3_libversion_number sqlite3_api->libversion_number |
| | | #define sqlite3_malloc sqlite3_api->malloc |
| | | #define sqlite3_mprintf sqlite3_api->mprintf |
| | | #define sqlite3_open sqlite3_api->open |
| | | #define sqlite3_open16 sqlite3_api->open16 |
| | | #define sqlite3_prepare sqlite3_api->prepare |
| | | #define sqlite3_prepare16 sqlite3_api->prepare16 |
| | | #define sqlite3_prepare_v2 sqlite3_api->prepare_v2 |
| | | #define sqlite3_prepare16_v2 sqlite3_api->prepare16_v2 |
| | | #define sqlite3_profile sqlite3_api->profile |
| | | #define sqlite3_progress_handler sqlite3_api->progress_handler |
| | | #define sqlite3_realloc sqlite3_api->realloc |
| | | #define sqlite3_reset sqlite3_api->reset |
| | | #define sqlite3_result_blob sqlite3_api->result_blob |
| | | #define sqlite3_result_double sqlite3_api->result_double |
| | | #define sqlite3_result_error sqlite3_api->result_error |
| | | #define sqlite3_result_error16 sqlite3_api->result_error16 |
| | | #define sqlite3_result_int sqlite3_api->result_int |
| | | #define sqlite3_result_int64 sqlite3_api->result_int64 |
| | | #define sqlite3_result_null sqlite3_api->result_null |
| | | #define sqlite3_result_text sqlite3_api->result_text |
| | | #define sqlite3_result_text16 sqlite3_api->result_text16 |
| | | #define sqlite3_result_text16be sqlite3_api->result_text16be |
| | | #define sqlite3_result_text16le sqlite3_api->result_text16le |
| | | #define sqlite3_result_value sqlite3_api->result_value |
| | | #define sqlite3_rollback_hook sqlite3_api->rollback_hook |
| | | #define sqlite3_set_authorizer sqlite3_api->set_authorizer |
| | | #define sqlite3_set_auxdata sqlite3_api->set_auxdata |
| | | #define sqlite3_snprintf sqlite3_api->xsnprintf |
| | | #define sqlite3_step sqlite3_api->step |
| | | #define sqlite3_table_column_metadata sqlite3_api->table_column_metadata |
| | | #define sqlite3_thread_cleanup sqlite3_api->thread_cleanup |
| | | #define sqlite3_total_changes sqlite3_api->total_changes |
| | | #define sqlite3_trace sqlite3_api->trace |
| | | #ifndef SQLITE_OMIT_DEPRECATED |
| | | #define sqlite3_transfer_bindings sqlite3_api->transfer_bindings |
| | | #endif |
| | | #define sqlite3_update_hook sqlite3_api->update_hook |
| | | #define sqlite3_user_data sqlite3_api->user_data |
| | | #define sqlite3_value_blob sqlite3_api->value_blob |
| | | #define sqlite3_value_bytes sqlite3_api->value_bytes |
| | | #define sqlite3_value_bytes16 sqlite3_api->value_bytes16 |
| | | #define sqlite3_value_double sqlite3_api->value_double |
| | | #define sqlite3_value_int sqlite3_api->value_int |
| | | #define sqlite3_value_int64 sqlite3_api->value_int64 |
| | | #define sqlite3_value_numeric_type sqlite3_api->value_numeric_type |
| | | #define sqlite3_value_text sqlite3_api->value_text |
| | | #define sqlite3_value_text16 sqlite3_api->value_text16 |
| | | #define sqlite3_value_text16be sqlite3_api->value_text16be |
| | | #define sqlite3_value_text16le sqlite3_api->value_text16le |
| | | #define sqlite3_value_type sqlite3_api->value_type |
| | | #define sqlite3_vmprintf sqlite3_api->vmprintf |
| | | #define sqlite3_vsnprintf sqlite3_api->xvsnprintf |
| | | #define sqlite3_overload_function sqlite3_api->overload_function |
| | | #define sqlite3_prepare_v2 sqlite3_api->prepare_v2 |
| | | #define sqlite3_prepare16_v2 sqlite3_api->prepare16_v2 |
| | | #define sqlite3_clear_bindings sqlite3_api->clear_bindings |
| | | #define sqlite3_bind_zeroblob sqlite3_api->bind_zeroblob |
| | | #define sqlite3_blob_bytes sqlite3_api->blob_bytes |
| | | #define sqlite3_blob_close sqlite3_api->blob_close |
| | | #define sqlite3_blob_open sqlite3_api->blob_open |
| | | #define sqlite3_blob_read sqlite3_api->blob_read |
| | | #define sqlite3_blob_write sqlite3_api->blob_write |
| | | #define sqlite3_create_collation_v2 sqlite3_api->create_collation_v2 |
| | | #define sqlite3_file_control sqlite3_api->file_control |
| | | #define sqlite3_memory_highwater sqlite3_api->memory_highwater |
| | | #define sqlite3_memory_used sqlite3_api->memory_used |
| | | #define sqlite3_mutex_alloc sqlite3_api->mutex_alloc |
| | | #define sqlite3_mutex_enter sqlite3_api->mutex_enter |
| | | #define sqlite3_mutex_free sqlite3_api->mutex_free |
| | | #define sqlite3_mutex_leave sqlite3_api->mutex_leave |
| | | #define sqlite3_mutex_try sqlite3_api->mutex_try |
| | | #define sqlite3_open_v2 sqlite3_api->open_v2 |
| | | #define sqlite3_release_memory sqlite3_api->release_memory |
| | | #define sqlite3_result_error_nomem sqlite3_api->result_error_nomem |
| | | #define sqlite3_result_error_toobig sqlite3_api->result_error_toobig |
| | | #define sqlite3_sleep sqlite3_api->sleep |
| | | #define sqlite3_soft_heap_limit sqlite3_api->soft_heap_limit |
| | | #define sqlite3_vfs_find sqlite3_api->vfs_find |
| | | #define sqlite3_vfs_register sqlite3_api->vfs_register |
| | | #define sqlite3_vfs_unregister sqlite3_api->vfs_unregister |
| | | #define sqlite3_threadsafe sqlite3_api->xthreadsafe |
| | | #define sqlite3_result_zeroblob sqlite3_api->result_zeroblob |
| | | #define sqlite3_result_error_code sqlite3_api->result_error_code |
| | | #define sqlite3_test_control sqlite3_api->test_control |
| | | #define sqlite3_randomness sqlite3_api->randomness |
| | | #define sqlite3_context_db_handle sqlite3_api->context_db_handle |
| | | #define sqlite3_extended_result_codes sqlite3_api->extended_result_codes |
| | | #define sqlite3_limit sqlite3_api->limit |
| | | #define sqlite3_next_stmt sqlite3_api->next_stmt |
| | | #define sqlite3_sql sqlite3_api->sql |
| | | #define sqlite3_status sqlite3_api->status |
| | | #define sqlite3_backup_finish sqlite3_api->backup_finish |
| | | #define sqlite3_backup_init sqlite3_api->backup_init |
| | | #define sqlite3_backup_pagecount sqlite3_api->backup_pagecount |
| | | #define sqlite3_backup_remaining sqlite3_api->backup_remaining |
| | | #define sqlite3_backup_step sqlite3_api->backup_step |
| | | #define sqlite3_compileoption_get sqlite3_api->compileoption_get |
| | | #define sqlite3_compileoption_used sqlite3_api->compileoption_used |
| | | #define sqlite3_create_function_v2 sqlite3_api->create_function_v2 |
| | | #define sqlite3_db_config sqlite3_api->db_config |
| | | #define sqlite3_db_mutex sqlite3_api->db_mutex |
| | | #define sqlite3_db_status sqlite3_api->db_status |
| | | #define sqlite3_extended_errcode sqlite3_api->extended_errcode |
| | | #define sqlite3_log sqlite3_api->log |
| | | #define sqlite3_soft_heap_limit64 sqlite3_api->soft_heap_limit64 |
| | | #define sqlite3_sourceid sqlite3_api->sourceid |
| | | #define sqlite3_stmt_status sqlite3_api->stmt_status |
| | | #define sqlite3_strnicmp sqlite3_api->strnicmp |
| | | #define sqlite3_unlock_notify sqlite3_api->unlock_notify |
| | | #define sqlite3_wal_autocheckpoint sqlite3_api->wal_autocheckpoint |
| | | #define sqlite3_wal_checkpoint sqlite3_api->wal_checkpoint |
| | | #define sqlite3_wal_hook sqlite3_api->wal_hook |
| | | #define sqlite3_blob_reopen sqlite3_api->blob_reopen |
| | | #define sqlite3_vtab_config sqlite3_api->vtab_config |
| | | #define sqlite3_vtab_on_conflict sqlite3_api->vtab_on_conflict |
| | | /* Version 3.7.16 and later */ |
| | | #define sqlite3_close_v2 sqlite3_api->close_v2 |
| | | #define sqlite3_db_filename sqlite3_api->db_filename |
| | | #define sqlite3_db_readonly sqlite3_api->db_readonly |
| | | #define sqlite3_db_release_memory sqlite3_api->db_release_memory |
| | | #define sqlite3_errstr sqlite3_api->errstr |
| | | #define sqlite3_stmt_busy sqlite3_api->stmt_busy |
| | | #define sqlite3_stmt_readonly sqlite3_api->stmt_readonly |
| | | #define sqlite3_stricmp sqlite3_api->stricmp |
| | | #define sqlite3_uri_boolean sqlite3_api->uri_boolean |
| | | #define sqlite3_uri_int64 sqlite3_api->uri_int64 |
| | | #define sqlite3_uri_parameter sqlite3_api->uri_parameter |
| | | #define sqlite3_uri_vsnprintf sqlite3_api->xvsnprintf |
| | | #define sqlite3_wal_checkpoint_v2 sqlite3_api->wal_checkpoint_v2 |
| | | /* Version 3.8.7 and later */ |
| | | #define sqlite3_auto_extension sqlite3_api->auto_extension |
| | | #define sqlite3_bind_blob64 sqlite3_api->bind_blob64 |
| | | #define sqlite3_bind_text64 sqlite3_api->bind_text64 |
| | | #define sqlite3_cancel_auto_extension sqlite3_api->cancel_auto_extension |
| | | #define sqlite3_load_extension sqlite3_api->load_extension |
| | | #define sqlite3_malloc64 sqlite3_api->malloc64 |
| | | #define sqlite3_msize sqlite3_api->msize |
| | | #define sqlite3_realloc64 sqlite3_api->realloc64 |
| | | #define sqlite3_reset_auto_extension sqlite3_api->reset_auto_extension |
| | | #define sqlite3_result_blob64 sqlite3_api->result_blob64 |
| | | #define sqlite3_result_text64 sqlite3_api->result_text64 |
| | | #define sqlite3_strglob sqlite3_api->strglob |
| | | /* Version 3.8.11 and later */ |
| | | #define sqlite3_value_dup sqlite3_api->value_dup |
| | | #define sqlite3_value_free sqlite3_api->value_free |
| | | #define sqlite3_result_zeroblob64 sqlite3_api->result_zeroblob64 |
| | | #define sqlite3_bind_zeroblob64 sqlite3_api->bind_zeroblob64 |
| | | /* Version 3.9.0 and later */ |
| | | #define sqlite3_value_subtype sqlite3_api->value_subtype |
| | | #define sqlite3_result_subtype sqlite3_api->result_subtype |
| | | /* Version 3.10.0 and later */ |
| | | #define sqlite3_status64 sqlite3_api->status64 |
| | | #define sqlite3_strlike sqlite3_api->strlike |
| | | #define sqlite3_db_cacheflush sqlite3_api->db_cacheflush |
| | | /* Version 3.12.0 and later */ |
| | | #define sqlite3_system_errno sqlite3_api->system_errno |
| | | /* Version 3.14.0 and later */ |
| | | #define sqlite3_trace_v2 sqlite3_api->trace_v2 |
| | | #define sqlite3_expanded_sql sqlite3_api->expanded_sql |
| | | /* Version 3.18.0 and later */ |
| | | #define sqlite3_set_last_insert_rowid sqlite3_api->set_last_insert_rowid |
| | | /* Version 3.20.0 and later */ |
| | | #define sqlite3_prepare_v3 sqlite3_api->prepare_v3 |
| | | #define sqlite3_prepare16_v3 sqlite3_api->prepare16_v3 |
| | | #define sqlite3_bind_pointer sqlite3_api->bind_pointer |
| | | #define sqlite3_result_pointer sqlite3_api->result_pointer |
| | | #define sqlite3_value_pointer sqlite3_api->value_pointer |
| | | /* Version 3.22.0 and later */ |
| | | #define sqlite3_vtab_nochange sqlite3_api->vtab_nochange |
| | | #define sqlite3_value_nochange sqlite3_api->value_nochange |
| | | #define sqlite3_vtab_collation sqlite3_api->vtab_collation |
| | | /* Version 3.24.0 and later */ |
| | | #define sqlite3_keyword_count sqlite3_api->keyword_count |
| | | #define sqlite3_keyword_name sqlite3_api->keyword_name |
| | | #define sqlite3_keyword_check sqlite3_api->keyword_check |
| | | #define sqlite3_str_new sqlite3_api->str_new |
| | | #define sqlite3_str_finish sqlite3_api->str_finish |
| | | #define sqlite3_str_appendf sqlite3_api->str_appendf |
| | | #define sqlite3_str_vappendf sqlite3_api->str_vappendf |
| | | #define sqlite3_str_append sqlite3_api->str_append |
| | | #define sqlite3_str_appendall sqlite3_api->str_appendall |
| | | #define sqlite3_str_appendchar sqlite3_api->str_appendchar |
| | | #define sqlite3_str_reset sqlite3_api->str_reset |
| | | #define sqlite3_str_errcode sqlite3_api->str_errcode |
| | | #define sqlite3_str_length sqlite3_api->str_length |
| | | #define sqlite3_str_value sqlite3_api->str_value |
| | | /* Version 3.25.0 and later */ |
| | | #define sqlite3_create_window_function sqlite3_api->create_window_function |
| | | /* Version 3.26.0 and later */ |
| | | #define sqlite3_normalized_sql sqlite3_api->normalized_sql |
| | | /* Version 3.28.0 and later */ |
| | | #define sqlite3_stmt_isexplain sqlite3_api->stmt_isexplain |
| | | #define sqlite3_value_frombind sqlite3_api->value_frombind |
| | | /* Version 3.30.0 and later */ |
| | | #define sqlite3_drop_modules sqlite3_api->drop_modules |
| | | /* Version 3.31.0 and later */ |
| | | #define sqlite3_hard_heap_limit64 sqlite3_api->hard_heap_limit64 |
| | | #define sqlite3_uri_key sqlite3_api->uri_key |
| | | #define sqlite3_filename_database sqlite3_api->filename_database |
| | | #define sqlite3_filename_journal sqlite3_api->filename_journal |
| | | #define sqlite3_filename_wal sqlite3_api->filename_wal |
| | | /* Version 3.32.0 and later */ |
| | | #define sqlite3_create_filename sqlite3_api->create_filename |
| | | #define sqlite3_free_filename sqlite3_api->free_filename |
| | | #define sqlite3_database_file_object sqlite3_api->database_file_object |
| | | /* Version 3.34.0 and later */ |
| | | #define sqlite3_txn_state sqlite3_api->txn_state |
| | | /* Version 3.36.1 and later */ |
| | | #define sqlite3_changes64 sqlite3_api->changes64 |
| | | #define sqlite3_total_changes64 sqlite3_api->total_changes64 |
| | | /* Version 3.37.0 and later */ |
| | | #define sqlite3_autovacuum_pages sqlite3_api->autovacuum_pages |
| | | /* Version 3.38.0 and later */ |
| | | #define sqlite3_error_offset sqlite3_api->error_offset |
| | | #define sqlite3_vtab_rhs_value sqlite3_api->vtab_rhs_value |
| | | #define sqlite3_vtab_distinct sqlite3_api->vtab_distinct |
| | | #define sqlite3_vtab_in sqlite3_api->vtab_in |
| | | #define sqlite3_vtab_in_first sqlite3_api->vtab_in_first |
| | | #define sqlite3_vtab_in_next sqlite3_api->vtab_in_next |
| | | /* Version 3.39.0 and later */ |
| | | #ifndef SQLITE_OMIT_DESERIALIZE |
| | | #define sqlite3_deserialize sqlite3_api->deserialize |
| | | #define sqlite3_serialize sqlite3_api->serialize |
| | | #endif |
| | | #define sqlite3_db_name sqlite3_api->db_name |
| | | /* Version 3.40.0 and later */ |
| | | #define sqlite3_value_encoding sqlite3_api->value_encoding |
| | | /* Version 3.41.0 and later */ |
| | | #define sqlite3_is_interrupted sqlite3_api->is_interrupted |
| | | /* Version 3.43.0 and later */ |
| | | #define sqlite3_stmt_explain sqlite3_api->stmt_explain |
| | | /* Version 3.44.0 and later */ |
| | | #define sqlite3_get_clientdata sqlite3_api->get_clientdata |
| | | #define sqlite3_set_clientdata sqlite3_api->set_clientdata |
| | | #endif /* !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION) */ |
| | | |
| | | #if !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION) |
| | | /* This case when the file really is being compiled as a loadable |
| | | ** extension */ |
| | | # define SQLITE_EXTENSION_INIT1 const sqlite3_api_routines *sqlite3_api=0; |
| | | # define SQLITE_EXTENSION_INIT2(v) sqlite3_api=v; |
| | | # define SQLITE_EXTENSION_INIT3 \ |
| | | extern const sqlite3_api_routines *sqlite3_api; |
| | | #else |
| | | /* This case when the file is being statically linked into the |
| | | ** application */ |
| | | # define SQLITE_EXTENSION_INIT1 /*no-op*/ |
| | | # define SQLITE_EXTENSION_INIT2(v) (void)v; /* unused parameter */ |
| | | # define SQLITE_EXTENSION_INIT3 /*no-op*/ |
| | | #endif |
| | | |
| | | #endif /* SQLITE3EXT_H */ |