bool SylVNC::BltBitmap(SrvBitmap *pcDstBitmap, SrvBitmap *pcSrcBitmap,
IRect cSrcRect, IPoint cDstPos, int nMode)
{
if((!pcDstBitmap->m_bVideoMem) && (!pcSrcBitmap->m_bVideoMem))
{
// Off-screen to off-screen
return DisplayDriver::BltBitmap(pcDstBitmap, pcSrcBitmap, cSrcRect,
cDstPos, nMode);
}
int srcX1 = cSrcRect.left;
int srcY1 = cSrcRect.top;
int srcX2 = cSrcRect.right;
int srcY2 = cSrcRect.bottom;
int dstX1 = cDstPos.x;
int dstY1 = cDstPos.y;
int dstX2 = cDstPos.x + cSrcRect.Width();
int dstY2 = cDstPos.y + cSrcRect.Height();
if((pcDstBitmap->m_bVideoMem) && (pcSrcBitmap->m_bVideoMem))
{
if(nMode == DM_COPY)
// dbprintf("SylVNC::BltBitmap() - Screen to screen DM_COPY\n");
;
else if(nMode == DM_OVER)
dbprintf("SylVNC::BltBitmap() - Screen to screen DM_OVER\n");
else if(nMode == DM_BLEND)
dbprintf("SylVNC::BltBitmap() - Screen to screen DM_BLEND\n");
else
dbprintf("SylVNC::BltBitmap() - Unknown nMode = %d\n", nMode);
}
DisplayDriver::BltBitmap(pcDstBitmap, pcSrcBitmap, cSrcRect, cDstPos, nMode);
if(pcDstBitmap->m_bVideoMem)
{
// ACQUIRE RFB lock
m_cRFBLock.Lock();
rfbMarkRectAsModified( rfbScreen, dstX1, dstY1, dstX2 + 1, dstY2 + 1);
// RELEASE RFB lock
m_cRFBLock.Unlock();
}
if(pcSrcBitmap->m_bVideoMem)
{
// ACQUIRE RFB lock
m_cRFBLock.Lock();
rfbMarkRectAsModified( rfbScreen, srcX1, srcY1, srcX2 + 1, srcY2 + 1);
// RELEASE RFB lock
m_cRFBLock.Unlock();
}
resume_thread( rfbEventThread );
// rfbProcessEvents(rfbScreen, 0);
return true;
}
int ChangeEnergySpeed::Editor_CaptureGadget(const IPoint& mouse_pos, int x, int y)
{
// Преобразовываем координаты к координатам на поле
int mx = mouse_pos.x + GameSettings::FieldCoordMouse().x;
int my = mouse_pos.y + GameSettings::FieldCoordMouse().y;
IRect r (mx - (GameSettings::SQUARE_SIDE / 2), my - (GameSettings::SQUARE_SIDE / 2), 0, 0);
r.Inflate((GameSettings::SQUARE_SIDE / 2));
_sliderRect = IRect(_snapPoint.x * GameSettings::SQUARE_SIDE,_snapPoint.y * GameSettings::SQUARE_SIDE - 30,200,30);
if (r.Contains(_snapPoint * GameSettings::SQUARE_SIDE))
{
return (-2);
}
else if (_sliderRect.Contains(IPoint(mx,my)))
{
return (-3);
}
else
{
return (-1);
}
}
void ChipSelecter::Draw()
{
Render::device.SetTexturing(false);
Render::BeginColor(Color(100, 100, 100, 180));
Render::DrawRect(IRect(200, 150, 400, 300));
Render::EndColor();
Render::device.SetTexturing(true);
//IRect rect = Game::ChipColor::DRAW_RECT;
//Тут должно быть 44х44!
IRect rect = IRect(0,0,44,44);
for (int i = 0; i <= 6; i++)
{
int x = _chipXLeft + 50*(i%7);
int y = _chipYDown + 50*(3 - i/7);
FRect uv = Game::GetChipRect(i, false, false, false);
_chipsTex->Draw(rect.MovedBy(IPoint(x - rect.width/2, y - rect.height/2)), uv);
}
for (size_t i = 0; i < _chipColors.size(); i++)
{
int color = _chipColors[i];
int x = _chipXLeft + 50*(color%7);
int y = _chipYDown + 50*(3 - color/7);
Render::BeginColor(Color(100, 255, 255, 255));
for (int q = -1; q<=1; q++)
{
for (int w = -1; w<=1; w++)
{
DrawRamka(x+q, y+w);
}
}
Render::EndColor();
FRect uv = Game::GetChipRect(color, false, false, false);
Render::device.SetAlpha(static_cast<int>(150+80*sinf(_timer*6 + x - y/3)));
Render::device.SetBlendMode(Render::ADD);
_chipsTex->Draw(rect.MovedBy(IPoint(x - rect.width/2, y - rect.height/2)), uv);
Render::device.SetBlendMode(Render::ALPHA);
}
if (_underMouseChip >= 0)
{
int color = _underMouseChip;
int x = _chipXLeft + 50*(color%7);
int y = _chipYDown + 50*(3 - color/7);
Render::BeginColor(Color(0, 255, 0, 255));
DrawRamka(x, y);
Render::EndColor();
}
Render::BindFont("debug");
Render::PrintString(IPoint(370, 170), utils::lexical_cast(static_cast<int>(_chipColors.size())) + " colors", 1.f, CenterAlign);
}
void ChipSelecter::DrawRamka(int x, int y)
{
//Тут должно быть 44х44!
IRect rect = IRect(0,0,44,44);
Render::device.SetTexturing(false);
Render::DrawFrame(rect.MovedBy(IPoint(x - rect.width/2, y - rect.height/2)));
Render::device.SetTexturing(true);
}
KDE_NO_EXPORT void Surface::repaint (const SRect &rect) {
Matrix matrix;
IRect clip;
clipToScreen (this, matrix, clip);
IRect scr = matrix.toScreen (rect);
clip = clip.intersect (scr);
if (!clip.isEmpty ())
view_widget->scheduleRepaint (clip);
}
bool VMware::BltBitmap(SrvBitmap *pcDstBitmap, SrvBitmap *pcSrcBitmap,
IRect cSrcRect, IRect cDstRect, int nMode, int nAlpha)
{
if(((!pcDstBitmap->m_bVideoMem) && (!pcSrcBitmap->m_bVideoMem)) || nMode != DM_COPY || cSrcRect.Size() != cDstRect.Size())
{
// Off-screen to off-screen
return DisplayDriver::BltBitmap(pcDstBitmap, pcSrcBitmap, cSrcRect,
cDstRect, nMode, nAlpha);
}
IPoint cDstPos = cDstRect.LeftTop();
int srcX = cSrcRect.left;
int srcY = cSrcRect.top;
int dstX = cDstPos.x;
int dstY = cDstPos.y;
int width = cSrcRect.Width() + 1;
int height = cSrcRect.Height() + 1;
bool accelDmCopy = false;
if((pcDstBitmap->m_bVideoMem) && (pcSrcBitmap->m_bVideoMem))
{
if(nMode == DM_COPY)
accelDmCopy = m_regCapabilities & SVGA_CAP_RECT_COPY;
else if(nMode == DM_OVER)
dbprintf("VMware::BltBitmap() - Screen to screen DM_OVER\n");
else if(nMode == DM_BLEND)
dbprintf("VMware::BltBitmap() - Screen to screen DM_BLEND\n");
else
dbprintf("VMware::BltBitmap() - Unknown nMode = %d\n", nMode);
}
// ACQUIRE lock
m_cGELock.Lock();
if(accelDmCopy)
{
// Accelerated screen to screen DM_COPY
Fifo_RectCopy(srcX, srcY, dstX, dstY, width, height);
m_bFifoCmds = true;
}
else
{
if(m_bFifoCmds)
FifoSync();
DisplayDriver::BltBitmap(pcDstBitmap, pcSrcBitmap, cSrcRect,
cDstRect, nMode, nAlpha);
if(pcDstBitmap->m_bVideoMem)
Fifo_UpdateRect(dstX, dstY, width, height);
}
// RELEASE lock
m_cGELock.Unlock();
return true;
}
void LockBarriers::Editor_CutToClipboard(IRect part)
{
_clipboard.clear();
for(Barriers::iterator itr = _barriers.begin(); itr != _barriers.end(); )
{
if( part.Contains((*itr)->GetPos()) ) {
(*itr)->SetPos( (*itr)->GetPos() - part.LeftBottom() );
_clipboard.push_back(*itr);
itr = _barriers.erase(itr);
} else {
++itr;
}
}
}
void CoreDelegateImpl::Draw()
{
static float x = 50;
static float y = 600;
auto p_renderer = Core::GetRenderer();
IRect rect = p_renderer->GetTargetRectangle();
p_renderer->SetMatrix(MatrixMode::Projection, Matrix4f::CreateOrtho(0, rect.Width(), 0, rect.Height()));
std::wstring message = L"FPS: " + std::to_wstring(Core::GetApplication()->GetCurrentFPS());
auto en_font = Core::GetGlobalObject<Resources::ResourceManager>()->GetHandleToResource<Render::Font>("Arial_en");
auto arial_font = Core::GetGlobalObject<Resources::ResourceManager>()->GetHandleToResource<Render::Font>("Arial");
Core::GetGlobalObject<Render::FontManager>()->Render({ x, y }, 1.f, message, arial_font);
Core::GetGlobalObject<Render::FontManager>()->Render({ x, y - 50 }, 1.f, message_num_0, en_font);
Core::GetGlobalObject<Render::FontManager>()->Render({ x, y - 100 }, 1.f, L"Мама мыла раму!", arial_font);
}
void View::update(const InputState &state) {
if(state.isKeyDown('g')) {
if(m_is_visible) {
if(m_cell_size == 3)
m_cell_size = 6;
else if(m_cell_size == 6)
m_cell_size = 9;
else {
m_cell_size = 1;
m_is_visible = false;
}
}
else {
m_cell_size = 3;
m_is_visible = true;
}
}
int height_change = state.mouseWheelMove() +
(state.isKeyDownAuto(InputKey::pagedown)? -1 : 0) +
(state.isKeyDownAuto(InputKey::pageup)? 1 : 0);
if(height_change)
m_height = clamp(m_height + height_change, 0, (int)Grid::max_height);
{
int actions[TileGroup::Group::side_count] = {
InputKey::kp_1,
InputKey::kp_2,
InputKey::kp_3,
InputKey::kp_6,
InputKey::kp_9,
InputKey::kp_8,
InputKey::kp_7,
InputKey::kp_4
};
for(int n = 0; n < arraySize(actions); n++)
if(state.isKeyDownAuto(actions[n]))
m_view_pos += worldToScreen(TileGroup::Group::s_side_offsets[n] * m_cell_size);
}
if((state.isKeyPressed(InputKey::lctrl) && state.isMouseButtonPressed(InputButton::left)) ||
state.isMouseButtonPressed(InputButton::middle))
m_view_pos -= state.mouseMove();
IRect rect = worldToScreen(IBox(int3(0, 0, 0), asXZY(m_tile_map.dimensions(), 256)));
m_view_pos = vclamp(m_view_pos, rect.min(), rect.max() - m_view_size);
}
GroupPad::GroupPad(const IRect &rect, PGroupEditor editor, TileGroup *group)
:Window(rect), m_editor(editor), m_group(group) {
m_filter_box = make_shared<ComboBox>(IRect(0, 0, rect.width(), 22), 200,
"Filter: ", TileFilter::strings(), TileFilter::count);
attach(m_filter_box);
m_filter_box->selectEntry(editor->tileFilter());
}
void ChangeEnergySpeed::Draw()
{
Render::device.SetTexturing(false);
// Точка центрирования (краcная)
Render::device.SetTexturing(false);
IRect draw (_snapPoint.x * GameSettings::SQUARE_SIDE + (GameSettings::SQUARE_SIDE / 2), _snapPoint.y * GameSettings::SQUARE_SIDE + (GameSettings::SQUARE_SIDE / 2), 0, 0);
draw.Inflate(GameSettings::SQUARE_SIDE / 2);
if (_selected)
{
Render::BeginColor(Color(50,255,50,128));
}
else
{
Render::BeginColor(Color(20,80,20,128));
}
Render::DrawRect(draw);
Render::DrawFrame(draw);
Render::EndColor();
/*
Render::BeginColor(Color(255,80,20,128));
Render::DrawRect(_sliderRect);
//Render::DrawFrame(sliderRect);
Render::EndColor();
*/
Render::device.SetTexturing(true);
Render::BeginColor(Color(255,255,255,255));
Render::FreeType::BindFont("debug");
Render::PrintString(draw.x + 2, draw.y + 35, "Energy", 1.0f, LeftAlign, BaseLineAlign);
Render::PrintString(draw.x + 2, draw.y + 25, "speed:", 1.0f, LeftAlign, BaseLineAlign);
Render::PrintString(draw.x + 2, draw.y + 5, Float::ToStringF(_energyTimeScale), 1.0f, LeftAlign, BaseLineAlign);
Render::EndColor();
if (_selected)
{
_sliderTime.Draw();
}
}
void Window::setRect(const IRect &rect) {
DASSERT(!m_dragging_mode);
DASSERT(!rect.empty());
m_rect = rect;
setInnerRect(IRect({0, 0}, m_rect.size()));
updateRects();
}
bool VMware::FillRect(SrvBitmap *pcBitmap, const IRect& cRect,
const Color32_s& sColor, int nMode)
{
if(!pcBitmap->m_bVideoMem || nMode != DM_COPY)
{
/* Off-screen */
return DisplayDriver::FillRect(pcBitmap, cRect, sColor, nMode);
}
int dstX = cRect.left;
int dstY = cRect.top;
int width = cRect.Width() + 1;
int height = cRect.Height() + 1;
int nColor;
if (pcBitmap->m_eColorSpc == CS_RGB32)
nColor = COL_TO_RGB32(sColor);
else
nColor = COL_TO_RGB16(sColor);
bool accelOp = false;
// accelOp = m_regCapabilities & SVGA_CAP_RECT_FILL;
// ACQUIRE lock
m_cGELock.Lock();
if(accelOp)
{
/* Accelerated on-screen RectFill */
Fifo_RectFill(dstX, dstY, width, height, nColor);
m_bFifoCmds = true;
}
else
{
if(m_bFifoCmds)
FifoSync();
DisplayDriver::FillRect(pcBitmap, cRect, sColor, nMode);
Fifo_UpdateRect(dstX, dstY, width, height);
}
// RELEASE lock
m_cGELock.Unlock();
return true;
}
void EnergyReceiver::Editor_DrawIndicators(bool selected)
{
// подложка под приемником
Render::device.SetBlendMode(Render::ADD);
if (selected)
Render::BeginColor(Color(128, 255, 200, 48));
else
Render::BeginColor(Color(255, 100, 200, 48));
Render::device.SetTexturing(false);
IRect draw = GameSettings::CELL_RECT.Inflated(-2);
draw.MoveTo(GetIndex()*GameSettings::SQUARE_SIDE);
Render::DrawRect(draw);
Render::EndColor();
Render::device.SetBlendMode(Render::ALPHA);
}
void SquareNewInfo::Editor_CopyToClipboard(IRect part)
{
Game::FieldAddress offset(part.x, part.y);
_clipboard.clear();
for(std::map<Game::FieldAddress, InfoSquare>::iterator itr = _info.begin(); itr != _info.end(); ++itr)
{
if( part.Contains(itr->first.ToPoint()) )
_clipboard.insert( std::make_pair(itr->first - offset, itr->second) );
}
}
void SquareNewInfo::Editor_ClearFieldPart(IRect part)
{
for(std::map<Game::FieldAddress, InfoSquare>::iterator itr = _info.begin(); itr != _info.end(); )
{
if( part.Contains(itr->first.ToPoint()) ) {
itr = _info.erase(itr);
} else {
++itr;
}
}
}
ComboBox::ComboBox(const IRect &rect, int drop_size, const char *prefix, CRange<const char*> values)
:Window(rect), m_drop_size(drop_size), m_prefix(prefix) {
m_button = make_shared<Button>(IRect(int2(0, 0), rect.size()), "");
m_dummy = make_shared<ListBox>(IRect(0, 0, 10, 10));
attach(m_button);
for(auto value : values)
addEntry(value, ColorId::white);
if(!values.empty())
selectEntry(0);
}
void CoreDelegateImpl::Draw()
{
auto p_lights = Core::GetRenderer()->GetLightsController();
p_lights->DisableLighting();
drawGrid(100, 4);
p_lights->EnableLighting();
static float x = 50;
static float y = 600;
auto p_renderer = Core::GetRenderer();
IRect rect = p_renderer->GetTargetRectangle();
p_renderer->SetMatrix(MatrixMode::Projection, Matrix4f::CreateOrtho(0, rect.Width(), 0, rect.Height()));
std::wstring message = L"FPS: " + std::to_wstring(Core::GetApplication()->GetCurrentFPS());
auto en_font = Core::GetGlobalObject<Resources::ResourceManager>()->GetHandleToResource<Render::Font>("Arial_en");
auto p_font_mgr = Core::GetGlobalObject<Render::FontManager>();
p_font_mgr->Render({ x, 900 }, 0.6f, message, en_font);
p_font_mgr->Render({ x, 865 }, 0.6f, L"Vertices: " + std::to_wstring(Core::GetGlobalObject<Render::MeshSystem>()->GetVerticesRendered()), en_font);
p_font_mgr->Render({ x, 830 }, 0.6f, L"Trigs: " + std::to_wstring(Core::GetGlobalObject<Render::MeshSystem>()->GetTrianglesRendered()), en_font);
/*message = L"asdqwetbij[we6 ewrgasdf";
for (int i = 0; i < 100; ++i)
p_font_mgr->Render({ x, y }, 1.f, message, en_font);*/
}
void Window::drawWindow(Renderer2D &out, IRect rect, FColor color, int outline) {
FColor lighter(color.rgb() * 1.2f, color.a);
FColor darker(color.rgb() * 0.8f, color.a);
int aoutline = fwk::abs(outline);
if(outline) {
int2 hsize(rect.width(), aoutline);
int2 vsize(aoutline, rect.height());
FColor col1 = outline < 0? darker : lighter;
out.addFilledRect(IRect(rect.min, rect.min + hsize), col1);
out.addFilledRect(IRect(rect.min, rect.min + vsize), col1);
int2 p1(rect.min.x, rect.max.y - aoutline);
int2 p2(rect.max.x - aoutline, rect.min.y);
FColor col2 = outline < 0? lighter : darker;
out.addFilledRect(IRect(p1, p1 + hsize), col2);
out.addFilledRect(IRect(p2, p2 + vsize), col2);
}
int2 off(aoutline, aoutline);
out.addFilledRect(inset(rect, off, off), color);
}
static void clipToScreen (Surface *s, Matrix &m, IRect &clip) {
Surface *ps = s->parentNode ();
if (!ps) {
clip = IRect (s->bounds.x (), s->bounds.y (),
s->bounds.width (), s->bounds.height ());
m = Matrix (s->bounds.x (), s->bounds.y (), s->xscale, s->yscale);
} else {
clipToScreen (ps, m, clip);
IRect scr = m.toScreen (s->bounds);
clip = clip.intersect (scr);
Matrix m1 = m;
m = Matrix (s->bounds.x (), s->bounds.y (), s->xscale, s->yscale);
m.transform (m1);
if (!s->virtual_size.isEmpty ())
m.translate (-s->x_scroll, -s->y_scroll);
}
}
GroupEditor::GroupEditor(IRect rect)
:ui::Window(rect, Color(0, 0, 0)), m_tile_list(rect.width(), 2) {
m_view = clippedRect();
m_tile_group = nullptr;
m_current_entry = nullptr;
m_font = res::getFont(WindowStyle::fonts[1]);
m_mode = mAddRemove;
memset(m_offset, 0, sizeof(m_offset));
m_selected_group_id = 0;
m_selected_surface_id = -1;
m_select_mode = 0;
m_selection_mode = 0;
m_tile_filter = TileFilter::floors;
updateSelector();
}
void UIListBox::Render()
{
UIElementPtr pElement = elements_[0];
UIElementPtr pSelElement = elements_[1];
if (this->GetEnabled())
{
pElement->TextureColor().SetState(UICS_Normal);
pElement->FontColor().SetState(UICS_Normal);
pSelElement->TextureColor().SetState(UICS_Normal);
pSelElement->FontColor().SetState(UICS_Normal);
}
else
{
pElement->TextureColor().SetState(UICS_Disabled);
pElement->FontColor().SetState(UICS_Disabled);
pSelElement->TextureColor().SetState(UICS_Disabled);
pSelElement->FontColor().SetState(UICS_Disabled);
}
this->GetDialog()->DrawSprite(*pElement,
IRect(x_, y_, x_ + width_, y_ + height_));
// Render the text
if (!items_.empty())
{
// Find out the height of a single line of text
IRect rc = text_rc_;
IRect rcSel = selection_rc_;
rc.bottom() = static_cast<int32_t>(rc.top() + UIManager::Instance().GetFontSize(pElement->FontIndex()));
// Update the line height formation
text_height_ = rc.Height();
static bool bSBInit;
if (!bSBInit)
{
// Update the page size of the scroll bar
if (text_height_)
{
scroll_bar_.SetPageSize(text_rc_.Height() / text_height_);
}
else
{
scroll_bar_.SetPageSize(text_rc_.Height());
}
bSBInit = true;
}
rc.right() = text_rc_.right();
for (int i = static_cast<int>(scroll_bar_.GetTrackPos()); i < static_cast<int>(items_.size()); ++ i)
{
if (rc.bottom() > text_rc_.bottom())
{
break;
}
std::shared_ptr<UIListBoxItem> const & pItem = items_[i];
// Determine if we need to render this item with the
// selected element.
bool bSelectedStyle = false;
if (!(MULTI_SELECTION == style_) && (i == selected_))
{
bSelectedStyle = true;
}
else
{
if (MULTI_SELECTION == style_)
{
if (drag_
&& (((i >= selected_) && (i < sel_start_))
|| ((i <= selected_) && (i > sel_start_))))
{
bSelectedStyle = items_[sel_start_]->bSelected;
}
else
{
if (pItem->bSelected)
{
bSelectedStyle = true;
}
}
}
}
if (bSelectedStyle)
{
rcSel.top() = rc.top();
rcSel.bottom() = rc.bottom();
this->GetDialog()->DrawSprite(*pSelElement, rcSel);
this->GetDialog()->DrawString(pItem->strText, *pSelElement, rc);
}
else
{
this->GetDialog()->DrawString(pItem->strText, *pElement, rc);
}
rc += int2(0, text_height_);
}
}
// Render the scroll bar
scroll_bar_.Render();
}
void ScrollableSelectorWidget::Draw()
{
int y = 0;
int numDrawStrings = 0;
ItemsList::iterator firstItemIterator = _itemsList.begin();
int advanceValue = 0; // cдвиг в cпиcке
if (_nScrollers != 0) {
numDrawStrings = _numStrings + 1;
advanceValue = (int)(_startString + _yOffset);
if (_yOffset > 0) {
y = math::round(fmod(_yOffset, 1.0f) * _stringStep);
} else {
y = _stringStep + math::round(fmod(_yOffset, 1.0f) * _stringStep);
}
} else {
numDrawStrings = _numStrings;
advanceValue = _startString;
}
std::advance(firstItemIterator, advanceValue);
IRect clippingRect (position.x - width / 2, position.y - (_numStrings - 1) * _stringStep, width, _numStrings * _stringStep);
{
// Небольшое затенение фона cпиcка
Render::device.SetTexturing(false);
Render::BeginColor(Color(0, 0, 0, 127));
Render::DrawRect(clippingRect);
Render::EndColor();
}
{
// Риcуем полоcу прокрутки, чтобы было понятно, что
// что-то там внизу cпиcка не влезает в видимую облаcть
// Это подложка полоcы прокрутки
IRect scrollBar (clippingRect);
const int scrollBarWidth = 7;
scrollBar.x = scrollBar.x + scrollBar.width - scrollBarWidth;
scrollBar.width = scrollBarWidth;
// Это ползунок на полоcе прокрутки. Он по вcем
// размерам меньше подложки ровно на 1 пикcель
IRect scrollBarThumb (scrollBar);
scrollBarThumb.height -= 2;
scrollBarThumb.width -= 2;
scrollBarThumb.x += 1;
float heightTotal = float (_stringStep * _itemsList.size());
float heightVisible = float (_stringStep * _numStrings);
float thumbScale = heightVisible / heightTotal;
float thumbHeight = (float) scrollBarThumb.height;
float thumbOffset = (float) _stringStep * (float (_startString) + _yOffset);
// Недеюcь, никогда в cпиcке не будет миллиарда
thumbScale = math::clamp(0.0f, 1.0f, thumbScale);
// Приведённый размер ползунка полоcы прокрутки по выcоте...
scrollBarThumb.height = math::round(thumbHeight * thumbScale);
// Верхняя точка полоcы прокрутки на экране...
scrollBarThumb.y = scrollBar.y + scrollBar.height - 1;
scrollBarThumb.y -= math::round(thumbOffset * thumbScale);
scrollBarThumb.y -= scrollBarThumb.height;
// Из-за округлений может заехать ниже
if (scrollBarThumb.y < scrollBar.y + 1)
scrollBarThumb.y = scrollBar.y + 1;
Render::BeginColor(Color(0, 0, 0, 127));
Render::DrawRect(scrollBar);
Render::EndColor();
// Риcуем ползунок...
if (thumbScale < 1.0f)
{
// ... когда еcть что прокручивать
Render::BeginColor(Color(0, 191, 0));
Render::DrawRect(scrollBarThumb);
Render::EndColor();
Render::BeginColor(Color(0, 127, 0));
Render::DrawFrame(scrollBarThumb);
Render::EndColor();
}
else
{
// ... когда нечего прокручивать
Render::BeginColor(Color(76, 76, 76));
Render::DrawRect(scrollBarThumb);
Render::EndColor();
Render::BeginColor(Color(51, 51, 51));
Render::DrawFrame(scrollBarThumb);
Render::EndColor();
}
Render::device.SetTexturing(true);
}
Render::device.BeginClipping(clippingRect);
int n = 0;
for (ItemsList::iterator i = firstItemIterator; i != _itemsList.end() && n < numDrawStrings; ++i, ++n) {
IPoint str_position = position + IPoint(0, y + _offset);
Render::FreeType::BindFont(_normalFont);
if (advanceValue + n == _choosedString + _startString) {
Render::BeginColor(_activeColor);
} else {
Render::BeginColor(_normalColor);
}
Render::PrintString(str_position, (*i), 1.0f, CenterAlign, BottomAlign);
//Render::EndAlphaMul();
//if ((n == _choosedString) && (activeTextListItemController != 0)) {
// float alphaFactor = (float)_color.alpha/255.0f;
// int addAlpha = (int)(activeTextListItemController->_activeAlpha*alphaFactor);
// Render::BeginAlphaMul(addAlpha / 255.f);
// Render::device.SetBlendMode(Render::ADD);
// Render::PrintString(str_position, (*i), 1.0f, CenterAlign);
// Render::device.SetBlendMode(Render::ALPHA);
// Render::EndAlphaMul();
//}
y -= _stringStep;
Render::EndColor();
}
Render::device.EndClipping();
{
// Зелёная рамка вокруг cпиcка
Render::device.SetTexturing(false);
IRect rect (clippingRect);
Render::BeginColor(Color(0, 191, 0));
rect.Inflate(1);
Render::DrawFrame(rect);
Render::EndColor();
Render::BeginColor(Color(0, 127, 0, 127));
rect.Inflate(1);
Render::DrawFrame(rect);
Render::EndColor();
Render::device.SetTexturing(true);
}
}
TileSelector::TileSelector(IRect rect) :Window(rect, WindowStyle::gui_dark),
m_tile_list(rect.width(), 2), m_selection(nullptr) {
update();
}
void Window::setInnerRect(const IRect &rect) {
int2 isize = rect.size();
m_inner_rect.min = max(min(rect.min, {0, 0}), min(-isize + m_rect.size(), {0, 0}));
m_inner_rect.max = m_inner_rect.min + isize;
m_has_inner_rect = isize.x > m_rect.width() || isize.y > m_rect.height();
}
