int clSocketBase::ReadMessage(wxString& message, int timeout) throw (clSocketException)
{
size_t message_len(0);
size_t bytesRead(0);
int rc = Read( (char*)&message_len, sizeof(message_len), bytesRead, timeout);
if ( rc != kSuccess ) {
// timeout
return rc;
}
bytesRead = 0;
char *buff = new char[message_len+1];
memset(buff, 0, message_len+1);
rc = Read(buff, message_len, bytesRead, timeout);
if ( rc != kSuccess ) {
wxDELETEA( buff );
return rc;
}
if ( bytesRead == 0 ) {
// session was closed
wxDELETEA( buff );
throw clSocketException("connection closed by peer");
} else if ( bytesRead != message_len ) {
wxDELETEA( buff );
throw clSocketException("Wrong message length received");
}
buff[message_len] = '\0';
message = buff;
return kSuccess;
}
void* Entry()
{
while(!TestDestroy()) {
// First, poll the channel
int bytes = ssh_channel_poll_timeout(m_channel, 500, 0);
if(bytes == SSH_ERROR) {
// an error
clCommandEvent event(wxEVT_SSH_CHANNEL_READ_ERROR);
m_handler->AddPendingEvent(event);
break;
} else if(bytes == SSH_EOF) {
clCommandEvent event(wxEVT_SSH_CHANNEL_CLOSED);
m_handler->AddPendingEvent(event);
break;
} else if(bytes == 0) {
continue;
} else {
// there is something to read
char* buffer = new char[bytes + 1];
if(ssh_channel_read(m_channel, buffer, bytes, 0) != bytes) {
clCommandEvent event(wxEVT_SSH_CHANNEL_READ_ERROR);
m_handler->AddPendingEvent(event);
wxDELETEA(buffer);
break;
} else {
buffer[bytes] = 0;
clCommandEvent event(wxEVT_SSH_CHANNEL_READ_OUTPUT);
event.SetString(wxString(buffer, wxConvUTF8));
m_handler->AddPendingEvent(event);
wxDELETEA(buffer);
}
}
}
return NULL;
}
int wxMysqlPreparedStatementWrapper::RunQuery()
{
MYSQL_BIND* pBoundParameters = m_Parameters.GetMysqlParameterBindings();
int nBindReturn = m_pInterface->GetMysqlStmtBindParam()(m_pStatement, pBoundParameters);
if (nBindReturn != 0)
{
SetErrorCode(wxMysqlDatabase::TranslateErrorCode(m_pInterface->GetMysqlStmtErrno()(m_pStatement)));
SetErrorMessage(ConvertFromUnicodeStream(m_pInterface->GetMysqlStmtError()(m_pStatement)));
wxDELETEA(pBoundParameters);
ThrowDatabaseException();
return wxDATABASE_QUERY_RESULT_ERROR;
}
else
{
int nReturn = m_pInterface->GetMysqlStmtExecute()(m_pStatement);
if (nReturn != 0)
{
SetErrorCode(wxMysqlDatabase::TranslateErrorCode(m_pInterface->GetMysqlStmtErrno()(m_pStatement)));
SetErrorMessage(ConvertFromUnicodeStream(m_pInterface->GetMysqlStmtError()(m_pStatement)));
wxDELETEA(pBoundParameters);
ThrowDatabaseException();
return wxDATABASE_QUERY_RESULT_ERROR;
}
}
wxDELETEA(pBoundParameters);
return m_pInterface->GetMysqlStmtAffectedRows()(m_pStatement);
}
wxDatabaseResultSet* wxMysqlPreparedStatementWrapper::RunQueryWithResults()
{
wxMysqlPreparedStatementResultSet* pResultSet = NULL;
MYSQL_BIND* pBoundParameters = m_Parameters.GetMysqlParameterBindings();
if (m_pInterface->GetMysqlStmtBindParam()(m_pStatement, pBoundParameters))
{
SetErrorCode(wxMysqlDatabase::TranslateErrorCode(m_pInterface->GetMysqlStmtErrno()(m_pStatement)));
SetErrorMessage(ConvertFromUnicodeStream(m_pInterface->GetMysqlStmtError()(m_pStatement)));
wxDELETEA(pBoundParameters);
ThrowDatabaseException();
return NULL;
}
else
{
if (m_pInterface->GetMysqlStmtExecute()(m_pStatement) != 0)
{
SetErrorCode(wxMysqlDatabase::TranslateErrorCode(m_pInterface->GetMysqlStmtErrno()(m_pStatement)));
SetErrorMessage(ConvertFromUnicodeStream(m_pInterface->GetMysqlStmtError()(m_pStatement)));
wxDELETEA(pBoundParameters);
ThrowDatabaseException();
return NULL;
}
else
{
pResultSet = new wxMysqlPreparedStatementResultSet(m_pInterface, m_pStatement);
if (pResultSet)
pResultSet->SetEncoding(GetEncoding());
}
}
wxDELETEA(pBoundParameters);;
return pResultSet;
}
static void FreeConvertedArgs()
{
if ( gs_initData.argvOrig )
{
for ( int i = 0; i < gs_initData.argcOrig; i++ )
{
free(gs_initData.argvOrig[i]);
// gs_initData.argv[i] normally points to the same data
}
wxDELETEA(gs_initData.argvOrig);
wxDELETEA(gs_initData.argv);
gs_initData.argcOrig = gs_initData.argc = 0;
}
}
// as Empty, but also frees memory
void wxArrayString::Clear()
{
m_nSize =
m_nCount = 0;
wxDELETEA(m_pItems);
}
void GarbageTestCase::LoadGarbage()
{
srand(1234);
wxInitAllImageHandlers();
for (size_t size = 1; size < GARBAGE_DATA_SIZE; size *= size+1)
{
// first, generate some garbage data
unsigned char *data = new unsigned char[size];
for (size_t i = 0; i < size; i++)
data[i] = rand();
// write it to a file
wxString garbagename = wxFileName::CreateTempFileName("garbage");
CPPUNIT_ASSERT( !garbagename.empty() );
wxFile garbage(garbagename, wxFile::write);
CPPUNIT_ASSERT( garbage.IsOpened() );
CPPUNIT_ASSERT( garbage.Write(data, size) == size );
garbage.Close();
// try to load it by name
DoLoadFile(garbagename);
// try to load it from a wxInputStream
wxMemoryInputStream stream(data, size);
DoLoadStream(stream);
wxDELETEA(data);
}
}
wxByte* BCRYPT::Encrypt(wxByte* buffer, wxUint32 size, wxUint32* sizePadded)
{
// AES requires buffer to consist of blocks with 16 bytes (each)
// expand last block by padding zeros if required...
// -> the encrypted data in BnS seems already to be aligned to blocks
*sizePadded = size + (AES_BLOCK_SIZE - (size % AES_BLOCK_SIZE)) % AES_BLOCK_SIZE;
wxByte* out = new wxByte[*sizePadded];
wxByte* tmp = buffer;
if(*sizePadded > size)
{
tmp = (wxByte*)memcpy(new wxByte[*sizePadded], buffer, size);
memset(tmp+size, 0, *sizePadded - size);
}
AES_KEY encryptingContext;
AES_set_encrypt_key(CRYPT_KEY, CRYPT_KEY_LENGTH, &encryptingContext);
for(wxUint32 i=0; i<*sizePadded; i+=16)
{
AES_encrypt(tmp+i, out+i, &encryptingContext);
}
if(tmp != buffer)
{
wxDELETEA(tmp);
}
return out;
}
wxString BCRYPT::BytesToHex(wxByte* buffer, wxUint32 size)
{
wxString appendix = wxEmptyString;
if(size < 1)
{
return wxEmptyString;
}
/*
if(size > 1024)
{
size = 1024;
appendix = wxT("...");
}
*/
wxByte* hex = new wxByte[3*size];
hex[3*size-1] = '\0';
wxString tmp;
for(wxUint32 i=0; i<size; i++)
{
tmp = wxString::Format(wxT("%.2x"), buffer[i]);
hex[3*i] = tmp[0];
hex[3*i+1] = tmp[1];
if(i < size-1)
{
hex[3*i+2] = '-';
}
}
wxString out = wxString::FromAscii((char*)hex) + appendix;
wxDELETEA(hex);
return out;
}
void wxRegionIterator::CreateRects( const wxRegion& region )
{
wxDELETEA(m_rects);
m_numRects = 0;
GdkRegion *gdkregion = region.GetRegion();
if (!gdkregion)
return;
GdkRectangle *gdkrects = NULL;
gint numRects = 0;
gdk_region_get_rectangles( gdkregion, &gdkrects, &numRects );
m_numRects = numRects;
if (numRects)
{
m_rects = new wxRect[m_numRects];
for (size_t i=0; i < m_numRects; ++i)
{
GdkRectangle &gr = gdkrects[i];
wxRect &wr = m_rects[i];
wr.x = gr.x;
wr.y = gr.y;
wr.width = gr.width;
wr.height = gr.height;
}
}
g_free( gdkrects );
}
void wxHashTableBase::Destroy()
{
Clear();
wxDELETEA(m_table);
m_size = 0;
}
int clSocketBase::ReadMessage(wxString& message, int timeout) throw(clSocketException)
{
// send the length in string form to avoid binary / arch differences between remote and local machine
char msglen[11];
memset(msglen, 0, sizeof(msglen));
size_t message_len(0);
size_t bytesRead(0);
int rc = Read((char*)msglen, sizeof(msglen) - 1, bytesRead, timeout);
if(rc != kSuccess) {
// timeout
return rc;
}
// convert the string to int
message_len = ::atoi(msglen);
bytesRead = 0;
char* buff = new char[message_len + 1];
memset(buff, 0, message_len + 1);
// read the entire amount we need
int bytesLeft = message_len;
int totalRead = 0;
while(bytesLeft > 0) {
rc = Read(buff + totalRead, bytesLeft, bytesRead, timeout);
if(rc != kSuccess) {
wxDELETEA(buff);
return rc;
} else if(rc == 0) {
// session was closed
wxDELETEA(buff);
throw clSocketException("connection closed by peer");
} else {
bytesLeft -= bytesRead;
totalRead += bytesRead;
bytesRead = 0;
}
}
buff[message_len] = '\0';
message = buff;
return kSuccess;
}
void TdsResultSet::PopulateFieldMap()
{
//fprintf(stderr, "In TdsResultSet::PopulateFieldMap()\n");
TDSCOLUMN* curcol;
//switch (nResultType)
//{
// case TDS_ROW_RESULT:
m_pResultInfo = m_pDatabase->res_info;
for (int i = 0; i < m_pResultInfo->num_cols; i++)
{
curcol = m_pResultInfo->columns[i];
char* pCharBuffer = new char[(curcol->column_namelen)+1];
memset(pCharBuffer, 0, (curcol->column_namelen)+1);
strncpy(pCharBuffer, curcol->column_name, curcol->column_namelen);
wxString colName = ConvertFromUnicodeStream(pCharBuffer);
wxDELETEA(pCharBuffer);
//fprintf(stderr, "column name(%d) = '%s'\n", i, colName.c_str());
m_FieldLookupMap[colName] = i;
/*
src = curcol->column_data;
if (verbose)
{
srctype = curcol->column_type;
srclen = curcol->column_size;
tds_convert(&ctx, srctype, (TDS_CHAR *) src, srclen, SYBCHAR, &cr);
printf("col %i is %s\n", i, cr.c);
}
if (i == 0)
{
src_id = *(int *) src;
}
else
{
src_val = *(float *) src;
src_err = src_val - sybreal[src_id];
if (src_err != 0.0)
{
src_err = src_err / src_val;
}
if (src_err < -tolerance || src_err > tolerance)
{
//fprintf(stderr, "SYBREAL expected %.8g got %.8g\n",
sybreal[src_id], src_val);
//fprintf(stderr, "Error was %.4g%%\n", 100 * src_err);
return 1;
}
}*/
}
// row_count++;
// case TDS_COMPUTE_RESULT:
// break;
// default:
// fprintf(stderr, "tds_process_tokens() unexpected result\n");
// break;
//}
}
bool wxZlibOutputStream::Close()
{
DoFlush(true);
deflateEnd(m_deflate);
wxDELETE(m_deflate);
wxDELETEA(m_z_buffer);
return wxFilterOutputStream::Close() && IsOk();
}
void wxPrintData::SetPrivData( char *privData, int len )
{
wxDELETEA(m_privData);
m_privDataLen = len;
if (m_privDataLen > 0)
{
m_privData = new char[m_privDataLen];
memcpy( m_privData, privData, m_privDataLen );
}
}
void wxMysqlPreparedStatementResultSet::Close()
{
ResetErrorCodes();
CloseMetaData();
MYSQL_RES* pResultMetadata = m_pInterface->GetMysqlStmtResultMetadata()(m_pStatement);
if (!pResultMetadata)
{
SetErrorCode(wxMysqlDatabase::TranslateErrorCode(m_pInterface->GetMysqlStmtErrno()(m_pStatement)));
SetErrorMessage(ConvertFromUnicodeStream(m_pInterface->GetMysqlStmtError()(m_pStatement)));
ThrowDatabaseException();
}
else
{
int nParameters = m_pInterface->GetMysqlNumFields()(pResultMetadata);
for (int i=0; i<nParameters; i++)
{
// int nType = m_pResultBindings[i].buffer_type;
// if (nType == MYSQL_TYPE_STRING || nType == MYSQL_TYPE_VAR_STRING || nType == MYSQL_TYPE_BLOB
// || nType == MYSQL_TYPE_TINY_BLOB || nType == MYSQL_TYPE_MEDIUM_BLOB || nType == MYSQL_TYPE_LONG_BLOB)
// {
// void* pData = m_pResultBindings[i].buffer;
// if (pData != NULL)
// {
// free(m_pResultBindings[i].buffer);
// m_pResultBindings[i].buffer = NULL;
// }
// }
}
m_pInterface->GetMysqlFreeResult()(pResultMetadata);
}
IntToMysqlParameterMap::iterator start = m_BindingWrappers.begin();
IntToMysqlParameterMap::iterator stop = m_BindingWrappers.end();
while (start != stop)
{
wxDELETE((*start).second);
start++;
}
m_BindingWrappers.clear();
wxDELETEA(m_pResultBindings);
if (m_pStatement != NULL)
{
m_pInterface->GetMysqlStmtFreeResult()(m_pStatement);
if (m_bManageStatement)
m_pInterface->GetMysqlStmtClose()(m_pStatement);
m_pStatement = NULL;
}
}
void wxOGLCleanUp()
{
wxDELETEA(oglBuffer);
wxDELETE(g_oglBullseyeCursor);
wxDELETE(g_oglNormalFont);
wxDELETE(g_oglBlackPen);
wxDELETE(g_oglWhiteBackgroundPen);
wxDELETE(g_oglTransparentPen);
wxDELETE(g_oglWhiteBackgroundBrush);
wxDELETE(g_oglBlackForegroundPen);
OGLCleanUpConstraintTypes();
}
static void FreeConvertedArgs()
{
if ( gs_initData.argv )
{
for ( int i = 0; i < gs_initData.argc; i++ )
{
free(gs_initData.argv[i]);
}
wxDELETEA(gs_initData.argv);
gs_initData.argc = 0;
}
}
bool wxGISDisplay::DrawLine(OGRRawPoint* pOGRRawPoints, int nPointCount, bool bOwn, double dOffsetX, double dOffsetY, bool bIsRing)
{
if (NULL == pOGRRawPoints)
{
if(bOwn)
wxDELETEA(pOGRRawPoints);
return false;
}
ClipGeometryByEnvelope(pOGRRawPoints, &nPointCount, m_CurrentBoundsX8, !bIsRing);
cairo_move_to(m_saLayerCaches[m_nCurrentLayer].pCairoContext, pOGRRawPoints[0].x + dOffsetX, pOGRRawPoints[0].y + dOffsetY);
for(int i = 1; i < nPointCount; ++i)
{
wxCriticalSectionLocker locker(m_CritSect);
cairo_line_to(m_saLayerCaches[m_nCurrentLayer].pCairoContext, pOGRRawPoints[i].x + dOffsetX, pOGRRawPoints[i].y + dOffsetY);
}
if(bOwn)
wxDELETEA(pOGRRawPoints);
return true;
}
void wxRegionIterator::CreateRects( const wxRegion& region )
{
wxDELETEA(m_rects);
m_numRects = 0;
#ifdef __WXGTK3__
cairo_region_t* cairoRegion = region.GetRegion();
if (cairoRegion == NULL)
return;
m_numRects = cairo_region_num_rectangles(cairoRegion);
if (m_numRects)
{
m_rects = new wxRect[m_numRects];
for (int i = 0; i < m_numRects; i++)
{
GdkRectangle gr;
cairo_region_get_rectangle(cairoRegion, i, &gr);
wxRect &wr = m_rects[i];
wr.x = gr.x;
wr.y = gr.y;
wr.width = gr.width;
wr.height = gr.height;
}
}
#else
GdkRegion *gdkregion = region.GetRegion();
if (!gdkregion)
return;
GdkRectangle* gdkrects;
gdk_region_get_rectangles(gdkregion, &gdkrects, &m_numRects);
if (m_numRects)
{
m_rects = new wxRect[m_numRects];
for (int i = 0; i < m_numRects; ++i)
{
GdkRectangle &gr = gdkrects[i];
wxRect &wr = m_rects[i];
wr.x = gr.x;
wr.y = gr.y;
wr.width = gr.width;
wr.height = gr.height;
}
}
g_free( gdkrects );
#endif
}
wxRegionIterator& wxRegionIterator::operator=(const wxRegionIterator& ri)
{
if (this != &ri)
{
wxDELETEA(m_rects);
m_current = ri.m_current;
m_numRects = ri.m_numRects;
if ( m_numRects )
{
m_rects = new wxRect[m_numRects];
memcpy(m_rects, ri.m_rects, m_numRects * sizeof m_rects[0]);
}
}
return *this;
}
wxString TdsResultSet::GetResultString(int nField)
{
TDSCOLUMN *curcol = m_pDatabase->current_results->columns[nField-1];
TDS_CHAR *src = (TDS_CHAR *) curcol->column_data;
wxString strValue = wxEmptyString;
if (curcol->column_cur_size > 0)
{
char* pCharBuffer = new char[(curcol->column_cur_size)+1];
memset(pCharBuffer, 0, (curcol->column_cur_size)+1);
strncpy(pCharBuffer, src, curcol->column_cur_size);
//fprintf(stderr, "char buffer: '%s'\n", pCharBuffer);
strValue = ConvertFromUnicodeStream(pCharBuffer);
//fprintf(stderr, "strValue: '%s'\n", strValue.c_str());
wxDELETEA(pCharBuffer);
}
return strValue;
}
wxRegionIterator& wxRegionIterator::operator=(const wxRegionIterator& ri)
{
wxDELETEA(m_rects);
m_current = ri.m_current;
m_numRects = ri.m_numRects;
if ( m_numRects )
{
m_rects = new wxRect[m_numRects];
for ( unsigned int n = 0; n < m_numRects; n++ )
m_rects[n] = ri.m_rects[n];
}
else
{
m_rects = NULL;
}
return *this;
}
bool XDebugComThread::DoReadReply(std::string& reply, clSocketBase::Ptr_t client)
{
if(!client) {
return false;
}
try {
// Read the data length
wxString length;
while(true) {
char c = 0;
size_t count = 0;
client->Read(&c, 1, count);
if(c == 0) {
break;
}
length << c;
}
long dataLengh(0);
if(!length.ToCLong(&dataLengh)) {
// session terminated!
return false;
}
// Read the actual buffer
++dataLengh; // +1 for NULL
char* buffer = new char[dataLengh];
memset(buffer, 0, dataLengh);
size_t actualSize(0);
client->Read(buffer, dataLengh, actualSize);
std::string content(buffer, dataLengh);
reply.swap(content);
wxDELETEA(buffer);
} catch(clSocketException& e) {
wxUnusedVar(e);
return false;
}
return true;
}
wxPrintData& wxPrintData::operator=(const wxPrintData& data)
{
if ( &data == this )
return *this;
m_printNoCopies = data.m_printNoCopies;
m_printCollate = data.m_printCollate;
m_printOrientation = data.m_printOrientation;
m_printOrientationReversed = data.m_printOrientationReversed;
m_printerName = data.m_printerName;
m_colour = data.m_colour;
m_duplexMode = data.m_duplexMode;
m_printQuality = data.m_printQuality;
m_paperId = data.m_paperId;
m_paperSize = data.m_paperSize;
m_bin = data.m_bin;
m_media = data.m_media;
m_printMode = data.m_printMode;
m_filename = data.m_filename;
// UnRef old m_nativeData
if (m_nativeData)
{
m_nativeData->m_ref--;
if (m_nativeData->m_ref == 0)
delete m_nativeData;
}
// Set Ref new one
m_nativeData = data.GetNativeData();
m_nativeData->m_ref++;
wxDELETEA(m_privData);
m_privDataLen = data.GetPrivDataLen();
if (m_privDataLen > 0)
{
m_privData = new char[m_privDataLen];
memcpy( m_privData, data.GetPrivData(), m_privDataLen );
}
return *this;
}
// ----------------------------------------------------------------------------
void clKeyboardManager::DoUpdateFrame(wxFrame* frame, MenuItemDataIntMap_t& accels)
// ----------------------------------------------------------------------------
{
std::vector<wxAcceleratorEntry> table;
// Update menus. If a match is found remove it from the 'accel' table
wxMenuBar* menuBar = frame->GetMenuBar();
if(!menuBar) return;
for(size_t i = 0; i < menuBar->GetMenuCount(); ++i) {
wxMenu* menu = menuBar->GetMenu(i);
DoUpdateMenu(menu, accels, table);
}
if(!table.empty() || !accels.empty()) {
wxAcceleratorEntry* entries = new wxAcceleratorEntry[table.size() + accels.size()];
// append the globals
for(MenuItemDataIntMap_t::iterator iter = accels.begin(); iter != accels.end(); ++iter) {
wxString dummyText;
dummyText << iter->second.action << _T("\t") << iter->second.accel;
wxAcceleratorEntry* entry = wxAcceleratorEntry::Create(dummyText);
if(entry) {
wxString resourceIDstr = iter->second.resourceID;
long ldResourceID; resourceIDstr.ToLong(&ldResourceID);
//-entry->Set(entry->GetFlags(), entry->GetKeyCode(), wxXmlResource::GetXRCID(iter->second.resourceID));
entry->Set(entry->GetFlags(), entry->GetKeyCode(), ldResourceID);
table.push_back(*entry);
wxDELETE(entry);
}
}
for(size_t i = 0; i < table.size(); ++i) {
entries[i] = table.at(i);
}
wxAcceleratorTable acceleTable(table.size(), entries);
frame->SetAcceleratorTable(acceleTable);
wxDELETEA(entries);
}
}
//
// Cleans up any wxWidgets internal structures left lying around
//
void wxApp::CleanUp()
{
wxDELETEA(wxBuffer);
//
// PM-SPECIFIC CLEANUP
//
// wxSetKeyboardHook(false);
if (wxSTD_FRAME_ICON)
::WinFreeFileIcon(wxSTD_FRAME_ICON);
if (wxSTD_MDICHILDFRAME_ICON)
::WinFreeFileIcon(wxSTD_MDICHILDFRAME_ICON);
if (wxSTD_MDIPARENTFRAME_ICON)
::WinFreeFileIcon(wxSTD_MDIPARENTFRAME_ICON);
if (wxDEFAULT_FRAME_ICON)
::WinFreeFileIcon(wxDEFAULT_FRAME_ICON);
if (wxDEFAULT_MDICHILDFRAME_ICON)
::WinFreeFileIcon(wxDEFAULT_MDICHILDFRAME_ICON);
if (wxDEFAULT_MDIPARENTFRAME_ICON)
::WinFreeFileIcon(wxDEFAULT_MDIPARENTFRAME_ICON);
if ( wxDisableButtonBrush )
{
// TODO: ::DeleteObject( wxDisableButtonBrush );
}
wxDELETE(wxWinHandleHash);
// Delete Message queue
if (wxTheApp->m_hMq)
::WinDestroyMsgQueue(wxTheApp->m_hMq);
wxAppBase::CleanUp();
} // end of wxApp::CleanUp
void wxEmailMessage::DoAddAttachment(const wxString& filename, wxString& payload) const
{
wxString base64Attachment;
wxFileName fn(filename);
if(!fn.IsOk() || !fn.Exists()) return;
FILE* fp = fopen(fn.GetFullPath().mb_str(wxConvUTF8).data(), "rb");
if(fp) {
fseek(fp, 0, SEEK_END);
size_t len = ftell(fp);
fseek(fp, 0, SEEK_SET);
char* buffer = new char[len];
fread(buffer, 1, len, fp);
fclose(fp);
base64Attachment = ::wxBase64Encode(buffer, len);
wxDELETEA(buffer);
}
if(!base64Attachment.IsEmpty()) {
payload << "\r\n--" << BOUNDRY_LINE << "\r\n";
payload << "Content-Type: application/octet-stream; name=\"" << fn.GetFullName() << "\""
<< "\r\n";
payload << "Content-Transfer-Encoding: base64 \r\n";
payload << "Content-Disposition: attachement; filename=\"" << fn.GetFullName() << "\"\r\n";
payload << "\r\n";
// Split the content to 76 chars per line
while(!base64Attachment.IsEmpty()) {
size_t bytes = (base64Attachment.length() >= 76) ? 76 : base64Attachment.length();
wxString line = base64Attachment.Mid(0, bytes);
payload << line << "\r\n";
base64Attachment = base64Attachment.Mid(bytes);
}
}
}
void MiscTestCase::Delete()
{
// Allocate some arbitrary memory to get a valid pointer:
long *pointer = new long;
CPPUNIT_ASSERT( pointer != NULL );
// Check that wxDELETE sets the pointer to NULL:
wxDELETE( pointer );
CPPUNIT_ASSERT( pointer == NULL );
// Allocate some arbitrary array to get a valid pointer:
long *array = new long[ 3 ];
CPPUNIT_ASSERT( array != NULL );
// Check that wxDELETEA sets the pointer to NULL:
wxDELETEA( array );
CPPUNIT_ASSERT( array == NULL );
// this results in compilation error, as it should
#if 0
struct SomeUnknownStruct *p = NULL;
wxDELETE(p);
#endif
}
void wxJigsawShape::DrawShapeHeader(wxDC & dc, const wxPoint & pos,
const wxSize & size, const wxJigsawShapeStyle style)
{
wxPoint * points(NULL);
bool bDrawBevel = true;
wxColour bevelBright(200,200,200), bevelDarker(50,50,50);
if(dc.GetPen() == *wxTRANSPARENT_PEN)
{
wxColour aux;
aux = bevelBright;
bevelBright = bevelDarker;
bevelDarker = aux;
}
switch(style)
{
case wxJigsawShapeStyle::wxJS_TYPE_NUMERIC:
if(bDrawBevel)
{
wxPoint pos1(pos);
wxSize size1(size);
dc.SetPen(bevelDarker);
dc.DrawRoundedRectangle(pos1, size1, size1.GetHeight()/2);
dc.SetPen(bevelBright);
pos1.x += 1;
pos1.y += 1;
dc.DrawRoundedRectangle(pos1, size1, size1.GetHeight()/2);
dc.SetPen(*wxTRANSPARENT_PEN);
pos1.y -= 1;
dc.DrawRoundedRectangle(pos1, size, size.GetHeight()/2);
dc.SetPen(bevelDarker);
dc.DrawLine(pos1.x + size.GetHeight()/2, pos1.y, pos1.x + size.GetWidth() - size.GetHeight()/2, pos1.y);
}
else
{
dc.DrawRoundedRectangle(pos, size, size.GetHeight()/2);
}
break;
case wxJigsawShapeStyle::wxJS_TYPE_BOOLEAN:
// If it is possible to draw a shape then we will draw it
if(size.GetWidth() >= size.GetHeight())
{
points = new wxPoint[7];
points[0] = wxPoint(0, size.GetHeight()/2);
points[1] = wxPoint(size.GetHeight()/2, 0);
points[2] = wxPoint(size.GetWidth()-size.GetHeight()/2, 0);
points[3] = wxPoint(size.GetWidth(), size.GetHeight()/2);
points[4] = wxPoint(size.GetWidth()-size.GetHeight()/2, size.GetHeight());
points[5] = wxPoint(size.GetHeight()/2, size.GetHeight());
points[6] = wxPoint(0, size.GetHeight()/2);
dc.DrawPolygon(7, points, pos.x, pos.y);
if(bDrawBevel)
{
dc.SetPen(bevelDarker);
dc.DrawLines(3, points, pos.x, pos.y);
dc.SetPen(bevelBright);
dc.DrawLines(4, &points[3], pos.x, pos.y);
}
wxDELETEA(points);
}
else // If it is impossible to draw a shape then we will draw a rectangle
{
dc.DrawRectangle(pos, size);
}
break;
case wxJigsawShapeStyle::wxJS_TYPE_STRING:
// If it is possible to draw a shape then we will draw it
if(size.GetWidth() >= size.GetHeight())
{
/*
1/3,1
1/3,2/3
0,2/3
0,1/3
1/3,1/3
1/3,0
*/
points = new wxPoint[13];
points[0] = wxPoint(size.GetHeight()/3.0, size.GetHeight());
points[1] = wxPoint(size.GetHeight()/3.0, 2*size.GetHeight()/3.0);
points[2] = wxPoint(0, 2*size.GetHeight()/3.0);
points[3] = wxPoint(0, size.GetHeight()/3.0);
points[4] = wxPoint(size.GetHeight()/3.0, size.GetHeight()/3.0);
points[5] = wxPoint(size.GetHeight()/3.0, 0);
points[6] = wxPoint(size.GetWidth()-points[5].x, points[5].y);
points[7] = wxPoint(size.GetWidth()-points[4].x, points[4].y);
points[8] = wxPoint(size.GetWidth()-points[3].x, points[3].y);
points[9] = wxPoint(size.GetWidth()-points[2].x, points[2].y);
points[10] = wxPoint(size.GetWidth()-points[1].x, points[1].y);
points[11] = wxPoint(size.GetWidth()-points[0].x, points[0].y);
points[12] = points[0];
dc.DrawPolygon(13, points, pos.x, pos.y);
if(bDrawBevel)
{
dc.SetPen(bevelDarker);
dc.DrawLines(7, points, pos.x, pos.y);
dc.SetPen(bevelBright);
dc.DrawLines(6, &points[7], pos.x, pos.y);
}
wxDELETEA(points);
}
else // If it is impossible to draw a shape then we will draw a rectangle
{
dc.DrawRectangle(pos, size);
}
break;
case wxJigsawShapeStyle::wxJS_TYPE_NONE:
default:
dc.DrawRoundedRectangle(pos, size, 4);
break;
}
}
