void ActiveThreadTab::setSummaryActiveThread(TabRef tab_ref, ChattyPostDataRef post_data_ref)
{
reset();
setScrollPos(0, true);
m_selected_post_ref = nullptr;
if(tab_ref != nullptr && post_data_ref != nullptr)
{
std::list<ChattyPostDataRef>::const_iterator it = g_world_tree.m_tree.begin();
for(; it != g_world_tree.m_tree.end(); it++)
{
if((*it) == post_data_ref)
{
break;
}
}
PostRef post_ref = createThreadPost(tab_ref);
post_ref->fromChattyPostData(post_ref, *it, true, false);
m_threads.push_back(post_ref);
setupLinkages();
updateShape(m_window_size);
setSelectedPost(post_ref, false, false, false, 0.0f, false);
}
else
{
updateShape(m_window_size);
}
toolbarNeedsUpdate();
needsRedraw();
}
void ActiveThreadTab::worldTreeBuilt(TabRef tab_ref)
{
reset();
updateShape(m_window_size);
toolbarNeedsUpdate();
needsRedraw();
}
void Layer::recursiveNeedsRedraw()
{
needsRedraw();
for(auto sublayer : sublayers)
{
sublayer->recursiveNeedsRedraw();
}
}
void CandidateBar::setSpacing(int spacing)
{
if (m_spacing != spacing)
{
m_spacing = spacing;
Q_EMIT needsRedraw();
}
}
void CandidateBar::setScrollOffset(int offset)
{
if (m_scrollOffset != offset)
{
m_scrollOffset = offset;
Q_EMIT needsRedraw();
}
}
void Layer::rect(const Rect& r)
{
if(r != _rect)
{
if (r.size() != _rect.size())
{
needsRedraw();
}
if(superlayer)
{
superlayer->needsRedraw();
}
}
_rect = r;
}
void Tab::markAsRead()
{
for(std::list<PostRef>::iterator it = m_threads.begin();
it != m_threads.end();
it++)
{
ChattyPostDataRef post_data_ref = (*it)->getPostDataRef();
if(post_data_ref != nullptr)
{
post_data_ref->markAsRead(true);
}
}
toolbarNeedsUpdate();
needsRedraw();
}
Layer::Layer()
{
superlayer = NULL;
_cornerRadius = 0;
_backgroundColor = whiteColor;
_borderColor = clearColor;
_borderWidth = 0;
_opacity = 1.0f;
_visible = true;
_backgroundContentMode = LayerContentModeScaleToFill;
addDefaultKeyAccessors();
addDefaultActions();
composite(false);
needsRedraw();
}
void LatestChattySummaryTab::worldTreeBuilt(TabRef tab_ref)
{
reset();
for(std::list<ChattyPostDataRef>::const_iterator it = g_world_tree.m_tree.begin();
it != g_world_tree.m_tree.end();
it++)
{
PostRef post_ref = createThreadPost(tab_ref);
post_ref->fromChattyPostData(post_ref, *it, false, true);
m_threads.push_back(post_ref);
}
setupLinkages();
updateShape(m_window_size);
toolbarNeedsUpdate();
needsRedraw();
}
void ActiveThreadTab::worldTreeHasNewPosts(TabRef tab_ref,
const std::list<ChattyPostDataRef>& new_posts)
{
trackPositionBeforeChange();
bool something_changed = false;
if(m_threads.size() > 0)
{
chatty_post_id thread_id = m_threads.front()->getPostDataRef()->m_thread_id;
for(std::list<ChattyPostDataRef>::const_iterator it = new_posts.begin();
it != new_posts.end();
it++)
{
if((*it)->m_thread_id == thread_id)
{
PostRef parent = findById((*it)->m_parent_id);
if(parent != nullptr)
{
PostRef child = ReplyPost::create(tab_ref);
child->fromChattyPostData(child, *it, false, false);
parent->addChild(child);
child->setMe(child);
child->setParent(parent);
something_changed = true;
}
}
}
}
if(something_changed)
{
updateShape(m_window_size);
updatePositionAfterChange();
toolbarNeedsUpdate();
needsRedraw();
}
else
{
cancelPositionTracking();
}
}
// Reports whether the passed in layers have visible damage or are otherwise
// dirty because render properties changed.
// Assumes that layers in the list belong to same composition. ie. damage to
// one layer affects the others. A warning is logged if the assumption is wrong.
bool GLXGraphicsystem::needsRedraw(LayerList layers)
{
// TODO: Ignore damage from completely obscured surfaces
for (LayerListConstIterator layer = layers.begin(); layer != layers.end(); layer++)
{
if ((*layer)->getLayerType() == Hardware && layers.size() > 1)
{
// Damage in a hardware layer should not imply a redraw in other layers
LOG_WARNING("GLXGraphicsystem", "needsRedraw() called with layers not in the same composition");
}
if (needsRedraw(*layer))
{
return true;
}
}
return false;
}
void Tab::reset()
{
m_selected_post_ref = nullptr;
for(std::list<PostRef>::iterator it = m_threads.begin();
it != m_threads.end();
it++)
{
(*it)->clearLinkages();
}
for(std::list<PostRef>::iterator it = m_threads.begin();
it != m_threads.end();
it++)
{
(*it)->clear();
}
m_threads.clear();
needsRedraw();
}
void View::removeSubview(const ViewPtr& view)
{
if(containsSubview(view))
{
if(view->superview == this)
{
subviews.remove(view);
layer->removeSublayer(view->layer);
view->superview = NULL;
needsRedraw();
}
else
{
WOUT("tried to remove subview that was part of this view, but didn't have the correct superview, ignoring");
}
}
else
{
WOUT("tried to remove subview that wasn't part of this view, ignoring");
}
}
void Tab::updatePositionAfterChange()
{
if(m_tracking_change &&
m_selected_post_ref != nullptr)
{
float min_y, max_y;
m_selected_post_ref->getPostYRange(min_y, max_y);
if(m_selected_min_y_before_change != min_y)
{
float difference = m_selected_min_y_before_change - min_y;
float new_goto_scroll_offset = math<float>::min(0, math<float>::max(-(m_crest_rect.y2 - m_window_size.y), (m_goto_scroll_offset + difference)));
difference = new_goto_scroll_offset - m_goto_scroll_offset;
m_scroll_offset += difference;
m_goto_scroll_offset += difference;
needsRedraw();
}
}
m_tracking_change = false;
}
void LatestChattySummaryTab::refresh(TabRef tab_ref)
{
((LampApp*)app::App::get())->setSummaryActiveThread(nullptr);
m_scroll_offset = 0.0f;
m_goto_scroll_offset = 0.0f;
m_selected_post_ref = nullptr;
reset();
for(std::list<ChattyPostDataRef>::const_iterator it = g_world_tree.m_tree.begin();
it != g_world_tree.m_tree.end();
it++)
{
PostRef post_ref = createThreadPost(tab_ref);
post_ref->fromChattyPostData(post_ref, *it, false, true);
m_threads.push_back(post_ref);
}
setupLinkages();
updateShape(m_window_size);
toolbarNeedsUpdate();
needsRedraw();
}
void LatestChattySummaryTab::worldTreeHasNewPosts(TabRef tab_ref,
const std::list<ChattyPostDataRef>& new_posts)
{
trackPositionBeforeChange();
for(std::list<ChattyPostDataRef>::const_iterator it = new_posts.begin();
it != new_posts.end();
it++)
{
if((*it)->m_parent_id == 0 &&
(*it)->m_id == (*it)->m_thread_id)
{
PostRef post_ref = createThreadPost(tab_ref);
post_ref->fromChattyPostData(post_ref, *it, false, true);
m_threads.push_front(post_ref);
}
}
setupLinkages();
updateShape(m_window_size);
updatePositionAfterChange();
toolbarNeedsUpdate();
needsRedraw();
}
void Layer::backgroundContentMode(LayerContentMode v) { _backgroundContentMode = v; needsRedraw(); }
void Layer::borderWidth(f32 v) { _borderWidth=v; needsRedraw(); }
void Layer::backgroundImage(const ImagePtr& v) { _backgroundImage=v; needsRedraw(); }
void Layer::backgroundColor(const Color& v) {_backgroundColor = v; needsRedraw(); }
void Layer::borderColor(const Color& v) { _borderColor=v;needsRedraw(); }
void TextLayer::textColor(const Color& v) { _textColor = v; needsRedraw(); }
void Layer::cornerRadius(s16 v) {_cornerRadius=v; needsRedraw(); }
void TextLayer::insets(const Insets& v) { _insets = v; needsRedraw(); }
void Layer::composite(bool v)
{
_composite = v;
needsRedraw();
}
void TextLayer::alignment(TextAlignment v) { _alignment = v; needsRedraw(); }
void TextLayer::breakmode(BreakMode v) { _breakmode = v; needsRedraw(); }
bool Tab::setSelectedPost(PostRef post_ref,
bool adjust_scroll_pos,
bool snap,
bool keep_y_pos,
float y_pos,
bool by_mouse)
{
bool changed = false;
if(m_selected_post_ref != post_ref)
{
// unselect the selected first
if(m_selected_post_ref)
{
m_selected_post_ref->setSelected(false);
}
m_selected_post_ref = post_ref;
if(m_selected_post_ref)
{
m_selected_post_ref->setSelected(true);
updateShape(m_window_size);
if(adjust_scroll_pos)
{
float min_y, max_y;
m_selected_post_ref->getPostYRange(min_y, max_y);
if(max_y - min_y > m_window_size.y)
{
setScrollPos(-(min_y - 10.0f), snap);
}
else
{
if(keep_y_pos)
{
if(by_mouse)
{
if(y_pos > max_y)
{
offsetScroll(y_pos - ((min_y + max_y) / 2.0f), snap, false);
}
if(min_y < -m_scroll_offset)
{
offsetScroll((-m_scroll_offset) - min_y, snap, false);
}
else if(max_y >((-m_scroll_offset) + m_window_size.y))
{
offsetScroll(-(max_y - ((-m_scroll_offset) + m_window_size.y)), snap, false);
}
}
else
{
offsetScroll(y_pos - min_y, snap, false);
}
}
else
{
if(min_y < -m_scroll_offset)
{
offsetScroll((-m_scroll_offset) - min_y, snap, false);
}
else if(max_y >((-m_scroll_offset) + m_window_size.y))
{
offsetScroll(-(max_y - ((-m_scroll_offset) + m_window_size.y)), snap, false);
}
}
}
}
}
toolbarNeedsUpdate();
needsRedraw();
changed = true;
}
return changed;
}
void Tab::render(gl::FboRef text_fbo)
{
m_scrollbar->AsScrollbar()->render(text_fbo);
gl::translate(0, m_scroll_offset);
bool new_posts_above_screen = false;
bool new_posts_below_screen = false;
for(std::list<PostRef>::iterator it = m_threads.begin();
it != m_threads.end();
it++)
{
float minY, maxY;
(*it)->getThreadYRange(minY, maxY);
if(minY + m_scroll_offset > m_window_size.y)
{
// off-screen. Skip the rendering part
if(m_perform_newness_glow_check && !new_posts_below_screen && (*it)->anyNew())
{
new_posts_below_screen = true;
}
}
else if(maxY + m_scroll_offset < 0)
{
// off-screen. Skip the rendering part
if(m_perform_newness_glow_check && !new_posts_above_screen && (*it)->anyNew())
{
new_posts_above_screen = true;
}
}
else
{
(*it)->render(text_fbo,
-m_scroll_offset,
-m_scroll_offset + m_window_size.y,
new_posts_above_screen,
new_posts_below_screen);
}
}
gl::Texture2dRef crest_image = g_skin.getImage(image_type::SHACK_CREST);
if(crest_image &&
!(m_crest_rect.y1 + m_scroll_offset > m_window_size.y ||
m_crest_rect.y2 + m_scroll_offset < 0))
{
gl::color(1, 1, 1, 1);
gl::draw(crest_image, m_crest_rect);
}
if(m_perform_newness_glow_check && new_posts_above_screen)
{
gl::color(1, 1, 1, 1);
ci::ColorA new_color(g_skin.getColor(Skin::NEW_POST), 0.33f);
ci::ColorA new_color_fade(g_skin.getColor(Skin::NEW_POST), 0.0f);
gl::VertBatch batch(GL_TRIANGLES);
batch.color(new_color);
batch.vertex(vec2(0.0f, -m_scroll_offset));
batch.color(new_color_fade);
batch.vertex(vec2(0.0f, -m_scroll_offset + 20.0f));
batch.color(new_color_fade);
batch.vertex(vec2(m_window_size.x / 8.0f, -m_scroll_offset));
batch.color(new_color);
batch.vertex(vec2(m_window_size.x, -m_scroll_offset));
batch.color(new_color_fade);
batch.vertex(vec2(m_window_size.x, -m_scroll_offset + 20.0f));
batch.color(new_color_fade);
batch.vertex(vec2((m_window_size.x / 8.0f) * 7.0f, -m_scroll_offset));
batch.draw();
}
if(m_perform_newness_glow_check && new_posts_below_screen)
{
gl::color(1, 1, 1, 1);
ci::ColorA new_color(g_skin.getColor(Skin::NEW_POST), 0.33f);
ci::ColorA new_color_fade(g_skin.getColor(Skin::NEW_POST), 0.0f);
gl::VertBatch batch(GL_TRIANGLES);
batch.color(new_color);
batch.vertex(vec2(0.0f, -m_scroll_offset + m_window_size.y));
batch.color(new_color_fade);
batch.vertex(vec2(0.0f, -m_scroll_offset + m_window_size.y - 20.0f));
batch.color(new_color_fade);
batch.vertex(vec2(m_window_size.x / 8.0f, -m_scroll_offset + m_window_size.y));
batch.color(new_color);
batch.vertex(vec2(m_window_size.x, -m_scroll_offset + m_window_size.y));
batch.color(new_color_fade);
batch.vertex(vec2(m_window_size.x, -m_scroll_offset + m_window_size.y - 20.0f));
batch.color(new_color_fade);
batch.vertex(vec2((m_window_size.x / 8.0f) * 7.0f, -m_scroll_offset + m_window_size.y));
batch.draw();
}
if(m_scroll_offset != m_goto_scroll_offset)
{
float scroll_percentage = g_lamp_settings.getSmoothScrollSpeed();
m_scroll_offset = ((m_scroll_offset * (1.0f - scroll_percentage)) + (m_goto_scroll_offset * scroll_percentage));
if(fabs(m_scroll_offset - m_goto_scroll_offset) <= 1.0f)
{
m_scroll_offset = m_goto_scroll_offset;
}
updateScrollbar();
needsRedraw();
}
}
void Tab::mouseWheel(float wheel_increment)
{
offsetScroll(wheel_increment * (float)g_lamp_settings.getMouseWheelScrollSize(), false, true);
needsRedraw();
}
