void CArray3Df::IniSpace(int x, int y, int z, float IniVal)
{
if (pData != NULL)
DeleteSpace();
XSize = x;
YSize = y;
ZSize = z;
FullSize = x*y*z;
pData = new float[FullSize];
ResetSpace(IniVal);
}
CArray3Df& CArray3Df::operator=(const CArray3Df& rArray) //overload "="
{
DeleteSpace();
XSize = rArray.XSize;
YSize = rArray.YSize;
ZSize = rArray.ZSize;
FullSize = XSize*YSize*ZSize;
pData = new float[FullSize];
for(int i=0; i<FullSize; i++)
pData[i] = rArray[i];
return *this;
}
int CDb3Mmap::WipeContactHistory(DBContact *dbc)
{
// drop subContact's history if any
for (DWORD dwOffset = dbc->ofsFirstEvent; dwOffset != 0;) {
DBEvent *pev = (DBEvent*)DBRead(dwOffset, sizeof(DBEvent), NULL);
if (pev->signature != DBEVENT_SIGNATURE) // broken chain, don't touch it
return 2;
DWORD dwNext = pev->ofsNext;
DeleteSpace(dwOffset, offsetof(DBEvent, blob) + pev->cbBlob);
dwOffset = dwNext;
}
dbc->eventCount = 0; dbc->ofsFirstEvent = dbc->ofsLastEvent = dbc->ofsFirstUnread = dbc->tsFirstUnread = 0;
return 0;
}
DWORD CDb3Mmap::ReallocSpace(DWORD ofs, int oldSize, int newSize)
{
if (oldSize >= newSize)
return ofs;
DWORD ofsNew;
if (ofs + oldSize == m_dbHeader.ofsFileEnd) {
ofsNew = ofs;
m_dbHeader.ofsFileEnd += newSize - oldSize;
DBWrite(0, &m_dbHeader, sizeof(m_dbHeader));
log3("adding newspace %d@%08x+%d", newSize, ofsNew, oldSize);
}
else {
ofsNew = CreateNewSpace(newSize);
DBMoveChunk(ofsNew, ofs, oldSize);
DeleteSpace(ofs, oldSize);
}
return ofsNew;
}
static INT_PTR DeleteContact(WPARAM wParam,LPARAM lParam)
{
struct DBContact *dbc,*dbcPrev;
DWORD ofsThis,ofsNext,ofsFirstEvent;
struct DBContactSettings *dbcs;
struct DBEvent *dbe;
int index;
if((HANDLE)wParam==NULL) return 1;
EnterCriticalSection(&csDbAccess);
dbc=(struct DBContact*)DBRead(wParam,sizeof(struct DBContact),NULL);
if(dbc->signature!=DBCONTACT_SIGNATURE) {
LeaveCriticalSection(&csDbAccess);
return 1;
}
if ( (HANDLE)wParam == (HANDLE)dbHeader.ofsUser ) {
LeaveCriticalSection(&csDbAccess);
log0("FATAL: del of user chain attempted.");
return 1;
}
log0("del contact");
LeaveCriticalSection(&csDbAccess);
//call notifier while outside mutex
NotifyEventHooks(hContactDeletedEvent,wParam,0);
//get back in
EnterCriticalSection(&csDbAccess);
{ DBCachedContactValueList VLtemp;
VLtemp.hContact = (HANDLE)wParam;
if ( li.List_GetIndex(&lContacts,&VLtemp,&index))
{
DBCachedContactValueList *VL = ( DBCachedContactValueList* )lContacts.items[index];
DBCachedContactValue* V = VL->first;
while ( V != NULL ) {
DBCachedContactValue* V1 = V->next;
FreeCachedVariant(&V->value);
HeapFree( hCacheHeap, 0, V );
V = V1;
}
HeapFree( hCacheHeap, 0, VL );
if (VLtemp.hContact == hLastCachedContact)
hLastCachedContact = NULL;
li.List_Remove(&lContacts,index);
} }
dbc=(struct DBContact*)DBRead(wParam,sizeof(struct DBContact),NULL);
//delete settings chain
ofsThis=dbc->ofsFirstSettings;
ofsFirstEvent=dbc->ofsFirstEvent;
while(ofsThis) {
dbcs=(struct DBContactSettings*)DBRead(ofsThis,sizeof(struct DBContactSettings),NULL);
ofsNext=dbcs->ofsNext;
DeleteSpace(ofsThis,offsetof(struct DBContactSettings,blob)+dbcs->cbBlob);
ofsThis=ofsNext;
}
//delete event chain
ofsThis=ofsFirstEvent;
while(ofsThis) {
dbe=(struct DBEvent*)DBRead(ofsThis,sizeof(struct DBEvent),NULL);
ofsNext=dbe->ofsNext;
DeleteSpace(ofsThis,offsetof(struct DBEvent,blob)+dbe->cbBlob);
ofsThis=ofsNext;
}
//find previous contact in chain and change ofsNext
dbc=(struct DBContact*)DBRead(wParam,sizeof(struct DBContact),NULL);
if(dbHeader.ofsFirstContact==wParam) {
dbHeader.ofsFirstContact=dbc->ofsNext;
DBWrite(0,&dbHeader,sizeof(dbHeader));
}
else {
ofsNext=dbc->ofsNext;
ofsThis=dbHeader.ofsFirstContact;
dbcPrev=(struct DBContact*)DBRead(ofsThis,sizeof(struct DBContact),NULL);
while(dbcPrev->ofsNext!=wParam) {
if(dbcPrev->ofsNext==0) DatabaseCorruption(NULL);
ofsThis=dbcPrev->ofsNext;
dbcPrev=(struct DBContact*)DBRead(ofsThis,sizeof(struct DBContact),NULL);
}
dbcPrev->ofsNext=ofsNext;
DBWrite(ofsThis,dbcPrev,sizeof(struct DBContact));
{
DBCachedContactValueList VLtemp;
VLtemp.hContact = (HANDLE)ofsThis;
if ( li.List_GetIndex(&lContacts,&VLtemp,&index))
{
DBCachedContactValueList *VL = ( DBCachedContactValueList* )lContacts.items[index];
VL->hNext = ( HANDLE )ofsNext;
} }
}
//delete contact
DeleteSpace(wParam,sizeof(struct DBContact));
//decrement contact count
dbHeader.contactCount--;
DBWrite(0,&dbHeader,sizeof(dbHeader));
DBFlush(0);
//quit
LeaveCriticalSection(&csDbAccess);
return 0;
}
CArray3Df::~CArray3Df(void)
{
DeleteSpace();
}
STDMETHODIMP_(BOOL) CDb3Mmap::DeleteEvent(MCONTACT contactID, HANDLE hDbEvent)
{
DBCachedContact *cc;
if (contactID) {
if ((cc = m_cache->GetCachedContact(contactID)) == NULL)
return 2;
if (cc->IsSub())
if ((cc = m_cache->GetCachedContact(cc->parentID)) == NULL)
return 3;
}
else cc = NULL;
mir_cslockfull lck(m_csDbAccess);
DWORD ofsContact = (cc) ? cc->dwDriverData : m_dbHeader.ofsUser;
DBContact dbc = *(DBContact*)DBRead(ofsContact, sizeof(DBContact), NULL);
DBEvent dbe = *(DBEvent*)DBRead((DWORD)hDbEvent, sizeof(DBEvent), NULL);
if (dbc.signature != DBCONTACT_SIGNATURE || dbe.signature != DBEVENT_SIGNATURE)
return 1;
lck.unlock();
log1("delete event @ %08x", hContact);
// call notifier while outside mutex
NotifyEventHooks(hEventDeletedEvent, contactID, (LPARAM)hDbEvent);
// get back in
lck.lock();
dbc = *(DBContact*)DBRead(ofsContact, sizeof(DBContact), NULL);
dbe = *(DBEvent*)DBRead((DWORD)hDbEvent, sizeof(DBEvent), NULL);
// check if this was the first unread, if so, recalc the first unread
if (dbc.ofsFirstUnread == (DWORD)hDbEvent) {
for (DBEvent *dbeNext = &dbe;;) {
if (dbeNext->ofsNext == 0) {
dbc.ofsFirstUnread = 0;
dbc.tsFirstUnread = 0;
break;
}
DWORD ofsThis = dbeNext->ofsNext;
dbeNext = (DBEvent*)DBRead(ofsThis, sizeof(DBEvent), NULL);
if (!dbeNext->markedRead()) {
dbc.ofsFirstUnread = ofsThis;
dbc.tsFirstUnread = dbeNext->timestamp;
break;
}
}
}
// get previous and next events in chain and change offsets
if (dbe.ofsPrev == 0) {
if (dbe.ofsNext == 0)
dbc.ofsFirstEvent = dbc.ofsLastEvent = 0;
else {
DBEvent *dbeNext = (DBEvent*)DBRead(dbe.ofsNext, sizeof(DBEvent), NULL);
dbeNext->ofsPrev = 0;
DBWrite(dbe.ofsNext, dbeNext, sizeof(DBEvent));
dbc.ofsFirstEvent = dbe.ofsNext;
}
}
else {
if (dbe.ofsNext == 0) {
DBEvent *dbePrev = (DBEvent*)DBRead(dbe.ofsPrev, sizeof(DBEvent), NULL);
dbePrev->ofsNext = 0;
DBWrite(dbe.ofsPrev, dbePrev, sizeof(DBEvent));
dbc.ofsLastEvent = dbe.ofsPrev;
}
else {
DBEvent *dbePrev = (DBEvent*)DBRead(dbe.ofsPrev, sizeof(DBEvent), NULL);
dbePrev->ofsNext = dbe.ofsNext;
DBWrite(dbe.ofsPrev, dbePrev, sizeof(DBEvent));
DBEvent *dbeNext = (DBEvent*)DBRead(dbe.ofsNext, sizeof(DBEvent), NULL);
dbeNext->ofsPrev = dbe.ofsPrev;
DBWrite(dbe.ofsNext, dbeNext, sizeof(DBEvent));
}
}
// decrement event count
dbc.eventCount--;
DBWrite(ofsContact, &dbc, sizeof(DBContact));
// delete event
DeleteSpace((DWORD)hDbEvent, offsetof(DBEvent, blob) + dbe.cbBlob);
// also update a sub
if (cc && dbe.contactID != cc->contactID) {
DBContact *pSub = (DBContact*)DBRead(GetContactOffset(dbe.contactID), sizeof(DBContact), NULL);
if (pSub->eventCount > 0)
pSub->eventCount--;
}
DBFlush(0);
return 0;
}
STDMETHODIMP_(LONG) CDb3Mmap::DeleteContact(MCONTACT contactID)
{
if (contactID == 0) // global contact cannot be removed
return 1;
mir_cslockfull lck(m_csDbAccess);
DWORD ofsContact = GetContactOffset(contactID);
DBContact *dbc = (DBContact*)DBRead(ofsContact, NULL);
if (dbc->signature != DBCONTACT_SIGNATURE)
return 1;
if (ofsContact == m_dbHeader.ofsUser) {
log0("FATAL: del of user chain attempted.");
return 1;
}
lck.unlock();
log0("del contact");
// call notifier while outside mutex
NotifyEventHooks(hContactDeletedEvent, contactID, 0);
// get back in
lck.lock();
// delete settings chain
DWORD ofsThis = dbc->ofsFirstSettings;
DWORD ofsFirstEvent = dbc->ofsFirstEvent;
while (ofsThis) {
DBContactSettings *dbcs = (DBContactSettings*)DBRead(ofsThis, NULL);
DWORD ofsNext = dbcs->ofsNext;
DeleteSpace(ofsThis, offsetof(DBContactSettings, blob) + dbcs->cbBlob);
ofsThis = ofsNext;
}
// delete event chain
ofsThis = ofsFirstEvent;
while (ofsThis) {
DBEvent *dbe = (DBEvent*)DBRead(ofsThis, NULL);
DWORD ofsNext = dbe->ofsNext;
DeleteSpace(ofsThis, offsetof(DBEvent, blob) + dbe->cbBlob);
ofsThis = ofsNext;
}
// find previous contact in chain and change ofsNext
if (m_dbHeader.ofsFirstContact == ofsContact) {
m_dbHeader.ofsFirstContact = dbc->ofsNext;
DBWrite(0, &m_dbHeader, sizeof(m_dbHeader));
}
else {
DWORD ofsNext = dbc->ofsNext;
ofsThis = m_dbHeader.ofsFirstContact;
DBContact *dbcPrev = (DBContact*)DBRead(ofsThis, NULL);
while (dbcPrev->ofsNext != ofsContact) {
if (dbcPrev->ofsNext == 0) DatabaseCorruption(NULL);
ofsThis = dbcPrev->ofsNext;
dbcPrev = (DBContact*)DBRead(ofsThis, NULL);
}
dbcPrev->ofsNext = ofsNext;
DBWrite(ofsThis, dbcPrev, sizeof(DBContact));
}
// delete contact
DeleteSpace(ofsContact, sizeof(DBContact));
// decrement contact count
m_dbHeader.contactCount--;
DBWrite(0, &m_dbHeader, sizeof(m_dbHeader));
DBFlush(0);
// free cache item
m_cache->FreeCachedContact(contactID);
if (contactID == m_hLastCachedContact)
m_hLastCachedContact = NULL;
return 0;
}