void String::Fill(s_char c, int ct) { MUTEX_LOCK(str_mutex); #ifdef SCRATCH_NO_UTF8 char* szBuffer = new char[ct + 1]; memset(szBuffer, c, ct); szBuffer[ct] = '\0'; CopyToBuffer(szBuffer); delete[] szBuffer; #else size_t charSize = utf8codepointsize(c); char* szChar = new char[charSize]; utf8catcodepoint(szChar, c, charSize); size_t size = ct * charSize; char* szBuffer = new char[size + 1]; for (int i = 0; i < ct; i++) { memcpy(szBuffer + i * charSize, szChar, charSize); } delete[] szChar; szBuffer[size] = '\0'; CopyToBuffer(szBuffer); delete[] szBuffer; #endif }
// Function to capture an area of the screen immediately prior to sending // an update. void vncDesktop::CaptureScreen(const rfb::Rect &rect, BYTE *scrBuff, UINT scrBuffSize) { assert(rect.enclosed_by(m_bmrect)); // Select the memory bitmap into the memory DC HBITMAP oldbitmap; if ((oldbitmap = (HBITMAP) SelectObject(m_hmemdc, m_membitmap)) == NULL) return; // Capture screen into bitmap BOOL blitok = BitBlt(m_hmemdc, rect.tl.x, rect.tl.y, (rect.br.x-rect.tl.x), (rect.br.y-rect.tl.y), m_hrootdc, rect.tl.x, rect.tl.y, SRCCOPY); // Select the old bitmap back into the memory DC SelectObject(m_hmemdc, oldbitmap); if (blitok) { // Copy the new data to the screen buffer (CopyToBuffer optimises this if possible) CopyToBuffer(rect, scrBuff, scrBuffSize); } }
Lin_StatusType Lin_GetStatus( uint8 Channel, uint8** Lin_SduPtr ) { volatile struct LINFLEX_tag * LINFLEXHw = LINFLEX(Channel); VALIDATE_W_RV( (LinDriverStatus != LIN_UNINIT), LIN_GETSTATUS_SERVICE_ID, LIN_E_UNINIT, LIN_NOT_OK); VALIDATE_W_RV( (LinChannelStatus[Channel] != LIN_CH_UNINIT), LIN_GETSTATUS_SERVICE_ID, LIN_E_CHANNEL_UNINIT, LIN_NOT_OK); VALIDATE_W_RV( (Channel < LIN_CONTROLLER_CNT), LIN_GETSTATUS_SERVICE_ID, LIN_E_INVALID_CHANNEL, LIN_NOT_OK); VALIDATE_W_RV( (Lin_SduPtr!=NULL), LIN_GETSTATUS_SERVICE_ID, LIN_E_INVALID_POINTER, LIN_NOT_OK); imask_t state; Irq_Save(state); Lin_StatusType res = LinChannelStatus[Channel]; /* We can only check for valid sdu ptr when LIN_RX_OK */ if(LinChannelStatus[Channel] == LIN_RX_OK || LinChannelStatus[Channel] == LIN_RX_ERROR){ CopyToBuffer(LinBufRx[Channel], LINFLEXHw); *Lin_SduPtr = LinBufRx[Channel]; if(LinChannelStatus[Channel] == LIN_RX_ERROR){ ResyncDriver(Channel); } LinChannelStatus[Channel]=LIN_CH_OPERATIONAL; } else if(LinChannelStatus[Channel] == LIN_TX_OK || LinChannelStatus[Channel] == LIN_TX_ERROR){ if(LinChannelStatus[Channel] == LIN_TX_ERROR){ ResyncDriver(Channel); } LinChannelStatus[Channel]=LIN_CH_OPERATIONAL; } Irq_Restore(state); return res; }
// Add the mouse pointer to the buffer void vncDesktop::CaptureMouse(BYTE *scrBuff, UINT scrBuffSize) { POINT CursorPos; ICONINFO IconInfo; // If the mouse cursor handle is invalid then forget it if (m_hcursor == NULL) return; // Get the cursor position if (!GetCursorPos(&CursorPos)) return; // Translate position for hotspot if (GetIconInfo(m_hcursor, &IconInfo)) { CursorPos.x -= ((int) IconInfo.xHotspot); CursorPos.y -= ((int) IconInfo.yHotspot); if (IconInfo.hbmMask != NULL) DeleteObject(IconInfo.hbmMask); if (IconInfo.hbmColor != NULL) DeleteObject(IconInfo.hbmColor); } // Select the memory bitmap into the memory DC HBITMAP oldbitmap; if ((oldbitmap = (HBITMAP) SelectObject(m_hmemdc, m_membitmap)) == NULL) return; // Draw the cursor DrawIconEx( m_hmemdc, // handle to device context CursorPos.x, CursorPos.y, m_hcursor, // handle to icon to draw 0,0, // width of the icon 0, // index of frame in animated cursor NULL, // handle to background brush DI_NORMAL | DI_COMPAT // icon-drawing flags ); // Select the old bitmap back into the memory DC SelectObject(m_hmemdc, oldbitmap); // Save the bounding rectangle m_cursorpos.tl = CursorPos; m_cursorpos.br = rfb::Point(GetSystemMetrics(SM_CXCURSOR), GetSystemMetrics(SM_CYCURSOR)).translate(CursorPos); // Clip the bounding rect to the screen // Copy the mouse cursor into the screen buffer, if any of it is visible m_cursorpos = m_cursorpos.intersect(m_bmrect); if (!m_cursorpos.is_empty()) { CopyToBuffer(m_cursorpos, scrBuff, scrBuffSize); } }
void CanvasRGB::SetHeight(int height) { if (height != _height && height > 0) { char *data = 0; if (_width > 0 && height > 0) { data = new char[_width * height * 3]; if (_height > 0) CopyToBuffer(data, _width, height, 0, 0); } _height = height; delete [] _data; _data = data; } }
void CanvasRGB::SetWidth(int width) { if (width != _width) { char *data = 0; if (width > 0 && _height > 0) { data = new char[width * _height * 3]; if (_width > 0) CopyToBuffer(data, width, _height, 0, 0); } _width = width; delete [] _data; _data = data; } }
std::string RopePiece::ToString() const { if (string_ != nullptr) { return std::string(string_); } if (prefix_ == nullptr) { if (suffix_ == nullptr) { return std::string(); } return suffix_->ToString(); } if (suffix_ == nullptr) { return prefix_->ToString(); } char* buffer = new char[length_ + 1]; CopyToBuffer(buffer); std::string ret_val(buffer); delete [] buffer; return ret_val; }
STDMETHODIMP CDataCallback::BandedDataCallback( LONG lReason, LONG lStatus, LONG lPercentComplete, LONG lOffset, LONG lLength, LONG, LONG, PBYTE pbBuffer ) { HRESULT hr; // Parse the message switch (lReason) { case IT_MSG_DATA_HEADER: { PWIA_DATA_CALLBACK_HEADER pHeader = (PWIA_DATA_CALLBACK_HEADER) pbBuffer; // Determine if this is a BMP transfer m_bBMP = pHeader->guidFormatID == WiaImgFmt_MEMORYBMP || pHeader->guidFormatID == WiaImgFmt_BMP; // For WiaImgFmt_MEMORYBMP transfers, WIA does not send a BITMAPFILEHEADER before the data. // In this program, we desire all BMP files to contain a BITMAPFILEHEADER, so add it manually m_nHeaderSize = pHeader->guidFormatID == WiaImgFmt_MEMORYBMP ? sizeof(BITMAPFILEHEADER) : 0; // Allocate memory for the image if the size is given in the header if (pHeader != NULL && pHeader->lBufferSize != 0) { hr = ReAllocBuffer(m_nHeaderSize + pHeader->lBufferSize); if (FAILED(hr)) { return hr; } } break; } case IT_MSG_DATA: { // Invoke the callback function hr = m_pfnProgressCallback(lStatus, lPercentComplete, m_pProgressCallbackParam); if (FAILED(hr) || hr == S_FALSE) { return hr; } // If the buffer is not allocated yet and this is the first block, // and the transferred image is in BMP format, allocate the buffer // according to the size information in the bitmap header if (m_pStream == NULL && lOffset == 0 && m_bBMP) { LONG nBufferSize = BitmapUtil::GetBitmapSize(pbBuffer); if (nBufferSize != 0) { hr = ReAllocBuffer(m_nHeaderSize + nBufferSize); if (FAILED(hr)) { return hr; } } } if (m_nHeaderSize + lOffset + lLength < 0) { return E_OUTOFMEMORY; } // If the transfer goes past the buffer, try to expand it if (m_nHeaderSize + lOffset + lLength > m_nDataSize) { hr = ReAllocBuffer(m_nHeaderSize + lOffset + lLength); if (FAILED(hr)) { return hr; } } // copy the transfer buffer hr = CopyToBuffer(m_nHeaderSize + lOffset, pbBuffer, lLength); if (FAILED(hr)) { return hr; } break; } case IT_MSG_STATUS: { // Invoke the callback function hr = m_pfnProgressCallback(lStatus, lPercentComplete, m_pProgressCallbackParam); if (FAILED(hr) || hr == S_FALSE) { return hr; } break; } case IT_MSG_TERMINATION: case IT_MSG_NEW_PAGE: { if (m_pStream != NULL) { // For BMP files, we should validate the the image header // So, obtain the memory buffer from the stream if (m_bBMP) { // Since the stream is created using CreateStreamOnHGlobal, // we can get the memory buffer with GetHGlobalFromStream. HGLOBAL hBuffer; hr = GetHGlobalFromStream(m_pStream, &hBuffer); if (FAILED(hr)) { return hr; } PBITMAPFILEHEADER pBuffer = (PBITMAPFILEHEADER) GlobalLock(hBuffer); if (pBuffer == NULL) { return HRESULT_FROM_WIN32(GetLastError()); } // Some scroll-fed scanners may return 0 as the bitmap height // In this case, calculate the image height and modify the header BitmapUtil::FixBitmapHeight(pBuffer + 1, m_nDataSize, TRUE); // For WiaImgFmt_MEMORYBMP transfers, the WIA service does not // include a BITMAPFILEHEADER preceeding the bitmap data. // In this case, fill in the BITMAPFILEHEADER structure. if (m_nHeaderSize != 0) { BitmapUtil::FillBitmapFileHeader(pBuffer + 1, pBuffer); } GlobalUnlock(hBuffer); } // Store this buffer in the successfully transferred images array hr = StoreBuffer(); if (FAILED(hr)) { return hr; } } break; } } return S_OK; }
/* as a result, updates the jello structure */ void RK4(cloth *clothItem) { int index; point *F1p, *F1v, *F2p, *F2v, *F3p, *F3v, *F4p, *F4v; F1p = (point*)calloc(clothItem->cArrayLength, sizeof(point)); F1v = (point*)calloc(clothItem->cArrayLength, sizeof(point)); F2p = (point*)calloc(clothItem->cArrayLength, sizeof(point)); F2v = (point*)calloc(clothItem->cArrayLength, sizeof(point)); F3p = (point*)calloc(clothItem->cArrayLength, sizeof(point)); F3v = (point*)calloc(clothItem->cArrayLength, sizeof(point)); F4p = (point*)calloc(clothItem->cArrayLength, sizeof(point)); F4v = (point*)calloc(clothItem->cArrayLength, sizeof(point)); cloth *buffer = (cloth*)malloc(1 * sizeof(cloth)); CopyToBuffer(buffer, clothItem); computeAcceleration(clothItem); for(int row = 0; row < clothItem->height; row++) { for(int col = 0; col < clothItem->width; col++) { index = FindIndexInArray(row, col, clothItem->width); // Pin Check if(gPin == PINNED) { if(index == 0 || index == clothItem->width-1) continue; } else if(gPin == UNPINLEFT) { if(index == clothItem->width-1) continue; } else if(gPin == UNPINRIGHT) { if(index == 0) continue; } pMULTIPLY(clothItem->velocities[index], clothItem->tStep, F1p[index]); pMULTIPLY(clothItem->acceleration[index], clothItem->tStep, F1v[index]); pMULTIPLY(F1p[index], 0.5, buffer->positions[index]); pMULTIPLY(F1v[index], 0.5, buffer->velocities[index]); pSUM(clothItem->positions[index], buffer->positions[index], buffer->positions[index]); pSUM(clothItem->velocities[index], buffer->velocities[index], buffer->velocities[index]); } } for(int i= 0; i < clothItem->cArrayLength; i++) { pCPY(clothItem->acceleration[i], buffer->acceleration[i]); } computeAcceleration(buffer); for(int row = 0; row < clothItem->height; row++) { for(int col = 0; col < clothItem->width; col++) { index = FindIndexInArray(row, col, clothItem->width); // Pin Check if(gPin == PINNED) { if(index == 0 || index == clothItem->width-1) continue; } else if(gPin == UNPINLEFT) { if(index == clothItem->width-1) continue; } else if(gPin == UNPINRIGHT) { if(index == 0) continue; } pMULTIPLY(buffer->velocities[index], clothItem->tStep, F2p[index]); pMULTIPLY(buffer->acceleration[index], clothItem->tStep, F2v[index]); pMULTIPLY(F2p[index], 0.5, buffer->positions[index]); pMULTIPLY(F2v[index], 0.5, buffer->velocities[index]); pSUM(clothItem->positions[index], buffer->positions[index], buffer->positions[index]); pSUM(clothItem->velocities[index], buffer->velocities[index], buffer->velocities[index]); } } computeAcceleration(buffer); for(int row = 0; row < clothItem->height; row++) { for(int col = 0; col < clothItem->width; col++) { index = FindIndexInArray(row, col, clothItem->width); // Pin Check if(gPin == PINNED) { if(index == 0 || index == clothItem->width-1) continue; } else if(gPin == UNPINLEFT) { if(index == clothItem->width-1) continue; } else if(gPin == UNPINRIGHT) { if(index == 0) continue; } pMULTIPLY(buffer->velocities[index], clothItem->tStep, F3p[index]); pMULTIPLY(buffer->acceleration[index], clothItem->tStep, F3v[index]); pMULTIPLY(F3p[index], 0.5, buffer->positions[index]); pMULTIPLY(F3v[index], 0.5, buffer->velocities[index]); pSUM(clothItem->positions[index], buffer->positions[index], buffer->positions[index]); pSUM(clothItem->velocities[index], buffer->velocities[index], buffer->velocities[index]); } } computeAcceleration(buffer); for(int row = 0; row < clothItem->height; row++) { for(int col = 0; col < clothItem->width; col++) { index = FindIndexInArray(row, col, clothItem->width); // Pin Check if(gPin == PINNED) { if(index == 0 || index == clothItem->width-1) continue; } else if(gPin == UNPINLEFT) { if(index == clothItem->width-1) continue; } else if(gPin == UNPINRIGHT) { if(index == 0) continue; } pMULTIPLY(buffer->velocities[index], clothItem->tStep, F4p[index]); pMULTIPLY(buffer->acceleration[index], clothItem->tStep, F4v[index]); pMULTIPLY(F2p[index], 2, buffer->positions[index]); pMULTIPLY(F3p[index], 2, buffer->velocities[index]); pSUM(buffer->positions[index], buffer->velocities[index], buffer->positions[index]); pSUM(buffer->positions[index], F1p[index], buffer->positions[index]); pSUM(buffer->positions[index], F4p[index], buffer->positions[index]); pMULTIPLY(buffer->positions[index], 1.0 / 6, buffer->positions[index]); pSUM(buffer->positions[index], clothItem->positions[index], clothItem->positions[index]); pMULTIPLY(F2v[index], 2, buffer->positions[index]); pMULTIPLY(F3v[index], 2, buffer->velocities[index]); pSUM(buffer->positions[index], buffer->velocities[index], buffer->positions[index]); pSUM(buffer->positions[index], F1v[index], buffer->positions[index]); pSUM(buffer->positions[index], F4v[index], buffer->positions[index]); pMULTIPLY(buffer->positions[index], 1.0 / 6, buffer->positions[index]); pSUM(buffer->positions[index], clothItem->velocities[index], clothItem->velocities[index]); } } for(int i= 0; i < clothItem->cArrayLength; i++) { pCPY(buffer->acceleration[i], clothItem->acceleration[i]); } for(int i= 0; i < clothItem->cArrayLength; i++) { // Pin Check if(gPin == PINNED) { if(index == 0 || index == clothItem->width-1) continue; } else if(gPin == UNPINLEFT) { if(index == clothItem->width-1) continue; } else if(gPin == UNPINRIGHT) { if(index == 0) continue; } pMULTIPLY(clothItem->velocities[i], gDelta, underWaterDamp); pSUM(clothItem->velocities[i], underWaterDamp, clothItem->velocities[i]); pSUM(clothItem->force[i], gravity, clothItem->force[i]); } free(buffer); return; }