void Button::OnPaint( PaintEventArgs* e )
{
if (_state == Hover)
{
set_BackColor(SystemColors::ButtonHighlight);
Image* image = _stateImages[Hover];
if (image == null)
image = _stateImages[Normal];
set_BackgroundImage(image, false);
}
else if (_state == HoverPressed)
{
set_BackColor(SystemColors::ButtonShadow);
Image* image = _stateImages[Pressed];
if (image == null)
image = _stateImages[Normal];
set_BackgroundImage(image, false);
}
else
{
set_BackColor(SystemColors::ButtonFace);
set_BackgroundImage(_stateImages[Normal], false);
}
ButtonBase::OnPaint(e);
Graphics& g = e->Graphics;
Drawing::Pen pen(Color::Black);
g.DrawRectangle(pen, 1, 1, get_Size().Width - 1, get_Size().Height - 1);
SolidBrush brush(SystemColors::ControlText);
g.DrawString(get_Text(), *SystemFonts::DefaultFont, brush, PointF(3, 3));
}
// Can both grow and reduse the size of ArraySet.
// Can truncate exisitng data !!
// If NewItemsCount is 0 then free memory.
// Note, that it requires additional memory buffer during work.
//
void ArraySet::Resize( vuint32 inNewItemsCount )
{
if( inNewItemsCount == 0 && mpStart ) // we want to free memory
{
FBL_CHECK( get_Size() <= sTotalSize );
sTotalSize -= get_Size();
delete [] mpStart;
mpStart = nullptr;
mpFinish = nullptr;
mpStorageEnd = nullptr;
}
else
{
ID_TYPE* pTmp = new ID_TYPE[inNewItemsCount];
// vuint32 MaxCount = get_MaxCount();
vuint32 Count = get_Count();
// Choose a min value:
// IF NewItemsCount is less THEN we trucate existing data.
Count = (Count < inNewItemsCount) ? Count : inNewItemsCount;
if( mpStart )
{
memcpy( (char*)pTmp, (char*)mpStart, Count * sizeof(ID_TYPE) );
delete [] mpStart;
}
// fill by zero rest items if any.
memset( pTmp + Count, 0, inNewItemsCount - Count );
mpStart = pTmp;
mpFinish = mpStart + Count;
mpStorageEnd = mpStart + inNewItemsCount;
// CORRECT counter using +/- diff value.
vint32 diff = (inNewItemsCount > Count) ? + (vint32)(inNewItemsCount - Count)
: - (vint32)(Count - inNewItemsCount);
sTotalSize += diff * sizeof(ID_TYPE);
}
}
ArraySet::~ArraySet( void )
{
sTotalSize -= get_Size();
if( mpStart )
delete [] mpStart;
mpStart = nullptr;
mpFinish = nullptr;
mpStorageEnd = nullptr;
}
void Button::OnMouseMove( MouseEventArgs* e )
{
Control::OnMouseMove(e);
if (!Drawing::Rectangle(Point::Empty, get_Size()).Contains(e->Location))
{
_state = static_cast<State>(_state & ~Hover);
}
else
{
_state = static_cast<State>(_state | Hover);
}
}
void ArraySet::InitSelf( vuint32 inMaxCount )
{
if( inMaxCount )
{
mpStart = new ID_TYPE[inMaxCount];
mpFinish = mpStart;
mpStorageEnd = mpStart + inMaxCount;
sTotalSize += get_Size();
}
else
{
mpStart = nullptr;
mpFinish = nullptr;
mpStorageEnd = nullptr;
}
mIsSorted = false;
}
void Button::OnMouseUp( MouseEventArgs* e )
{
Control::OnMouseUp(e);
if (e->Button != MouseButtons::Left)
return;
if (Drawing::Rectangle(Point::Empty, get_Size()).Contains(e->Location))
{
if (_state & Pressed)
{
OnClick(&EventArgs::Empty);
}
_state = Hover;
}
else
{
_state = Normal;
}
}
void sf_free(void *ptr){
/* ptr is not a valid address within dynamic memory space */
if(ptr < start || ptr >= end) return;
/* address provided is already a free region of memory */
if((*(((uintptr_t*)ptr) - 1) & EXTRACT_MARKER_BIT) == MARK_FREE)
return;
uintptr_t *cursor = (uintptr_t*) (((uintptr_t*) ptr) - 1);
uintptr_t ptr_as_int = (uintptr_t) cursor;
ptr_as_int = ptr_as_int & 0xF;
if(ptr_as_int != 8){
errno = ENOMEM;
return;
}
uintptr_t cursorSize = get_loadSize(cursor);
uintptr_t *cursorFooter = cursor + (cursorSize / 8) + 1;
uintptr_t *newBlockHeader = (uintptr_t*) NULL_POINTER;
uintptr_t *newBlockFooter = (uintptr_t*) NULL_POINTER;
uintptr_t *previousFooter = cursor - 1;
if((void*) previousFooter > start){
uintptr_t previousSize = get_loadSize(previousFooter);
uintptr_t perviousMarker = (uintptr_t) (*previousFooter & EXTRACT_MARKER_BIT);
uintptr_t *previousHeader = previousFooter - (previousSize / 8) - 1;
if((void*) previousHeader > start && perviousMarker == MARK_FREE){
uintptr_t *previousNext = (uintptr_t *) *(previousHeader + 1);
uintptr_t *previousPrevious = (uintptr_t*) *(previousHeader + 2);
if((uintptr_t) previousNext != NULL_POINTER && (uintptr_t) previousPrevious != NULL_POINTER){
*(previousNext + 2) = (uintptr_t) previousPrevious;
*(previousPrevious + 1) = (uintptr_t) previousNext;
newBlockHeader = previousHeader;
}else{
newBlockHeader = cursor;
}
}else{
newBlockHeader = cursor;
}
}else{
newBlockHeader = cursor;
}
uintptr_t *nextHeader = cursorFooter + 1;
if((void*) nextHeader < end){
uintptr_t nextSize = get_loadSize(nextHeader);
uintptr_t nextMarker = (uintptr_t) (*nextHeader & EXTRACT_MARKER_BIT);
uintptr_t *nextFooter = nextHeader + (nextSize / 8) + 1;
if((void*) nextFooter < end - 1 && nextMarker == MARK_FREE){
uintptr_t *nextNext = (uintptr_t*) *(nextHeader + 1);
uintptr_t *nextPrevious = (uintptr_t*) *(nextHeader + 2);
if((uintptr_t) nextNext != NULL_POINTER && (uintptr_t) nextPrevious != NULL_POINTER){
*(nextNext + 2) = (uintptr_t) nextPrevious;
*(nextPrevious + 1) = (uintptr_t) nextNext;
newBlockFooter = nextFooter;
}else{
newBlockFooter = cursorFooter;
}
}else{
newBlockFooter = cursorFooter;
}
}else{
newBlockFooter = cursorFooter;
}
uintptr_t newBlockSize = get_Size(newBlockHeader, newBlockFooter) + 8;
uintptr_t newBlockInfo = createHeader(0, newBlockSize, MARK_FREE);
*newBlockHeader = newBlockInfo;
*newBlockFooter = newBlockInfo;
insertHead(newBlockHeader);
}
