void List::draw_label_helper(const Cairo::RefPtr<Cairo::Context> & cr, ListNode * label, const char * text, int x, int y, LabelArrowPos arrowPos) {
cr->set_source_rgb(0.0, 0.0, 0.0);
Pango::FontDescription font;
font.set_family("Monospace");
font.set_weight(Pango::WEIGHT_BOLD);
Glib::RefPtr<Pango::Layout> layout = create_pango_layout(text);
layout->set_font_description(font);
int text_w, text_h;
layout->get_pixel_size(text_w, text_h);
cr->move_to(x, y);
layout->show_in_cairo_context(cr);
if (label != NULL) {
if (arrowPos == RIGHT) {
draw_arrow_helper(cr, x + text_w + 10, y + text_h / 2, label->x - 10, label->y + ListNode::field_h);
} else {
draw_arrow_helper(cr, x - 10, y + text_h / 2, label->x + ListNode::field_w + 10, label->y + ListNode::field_h);
}
} else {
if (arrowPos == RIGHT) {
draw_null_arrow(cr, x + text_w + 10, y + text_h / 2, true);
} else {
draw_null_arrow(cr, x - 10, y + text_h / 2, false);
}
}
}
static AtkAttributeSet*
gail_text_cell_get_default_attributes (AtkText *text)
{
GailRendererCell *gail_renderer;
GtkCellRendererText *gtk_renderer;
AtkAttributeSet *attrib_set = NULL;
PangoLayout *layout;
AtkObject *parent;
GtkWidget *widget;
gail_renderer = GAIL_RENDERER_CELL (text);
gtk_renderer = GTK_CELL_RENDERER_TEXT (gail_renderer->renderer);
parent = atk_object_get_parent (ATK_OBJECT (text));
if (GAIL_IS_CONTAINER_CELL (parent))
parent = atk_object_get_parent (parent);
g_return_val_if_fail (GAIL_IS_CELL_PARENT (parent), NULL);
widget = GTK_ACCESSIBLE (parent)->widget;
layout = create_pango_layout (gtk_renderer, widget),
attrib_set = gail_misc_get_default_attributes (attrib_set,
layout,
widget);
g_object_unref (G_OBJECT (layout));
return attrib_set;
}
static void
gail_text_cell_get_character_extents (AtkText *text,
gint offset,
gint *x,
gint *y,
gint *width,
gint *height,
AtkCoordType coords)
{
GailRendererCell *gail_renderer;
GtkCellRendererText *gtk_renderer;
GdkRectangle rendered_rect;
GtkWidget *widget;
AtkObject *parent;
PangoRectangle char_rect;
PangoLayout *layout;
gint x_offset, y_offset, index, cell_height, cell_width;
if (!GAIL_TEXT_CELL (text)->cell_text)
{
*x = *y = *height = *width = 0;
return;
}
if (offset < 0 || offset >= GAIL_TEXT_CELL (text)->cell_length)
{
*x = *y = *height = *width = 0;
return;
}
gail_renderer = GAIL_RENDERER_CELL (text);
gtk_renderer = GTK_CELL_RENDERER_TEXT (gail_renderer->renderer);
/*
* Thus would be inconsistent with the cache
*/
gail_return_if_fail (gtk_renderer->text);
parent = atk_object_get_parent (ATK_OBJECT (text));
if (GAIL_IS_CONTAINER_CELL (parent))
parent = atk_object_get_parent (parent);
widget = GTK_ACCESSIBLE (parent)->widget;
g_return_if_fail (GAIL_IS_CELL_PARENT (parent));
gail_cell_parent_get_cell_area (GAIL_CELL_PARENT (parent), GAIL_CELL (text),
&rendered_rect);
gtk_cell_renderer_get_size (GTK_CELL_RENDERER (gtk_renderer), widget,
&rendered_rect, &x_offset, &y_offset, &cell_width, &cell_height);
layout = create_pango_layout (gtk_renderer, widget);
index = g_utf8_offset_to_pointer (gtk_renderer->text,
offset) - gtk_renderer->text;
pango_layout_index_to_pos (layout, index, &char_rect);
gail_misc_get_extents_from_pango_rectangle (widget,
&char_rect,
x_offset + rendered_rect.x + gail_renderer->renderer->xpad,
y_offset + rendered_rect.y + gail_renderer->renderer->ypad,
x, y, width, height, coords);
g_object_unref (layout);
return;
}
// helper function to draw a number
void Draw::draw_num(const Cairo::RefPtr<Cairo::Context>& cr, const Pango::FontDescription & font,
const int num, const double x, const double y)
{
std::ostringstream str;
int txt_w, txt_h;
str<<num;
Glib::RefPtr<Pango::Layout> txt = create_pango_layout(str.str());
txt->set_font_description(font);
txt->get_pixel_size(txt_w, txt_h);
cr->move_to(x - .5 * txt_w, y - .5 * txt_h);
txt->show_in_cairo_context(cr);
}
TimeLine::TimeLine(LibbenchWindow* window)
: m_mainWindow(window)
, m_timeStart(0.0)
{
m_layout = create_pango_layout("");
m_font.set_family("DejaVu Sans");
m_font.set_weight(Pango::WEIGHT_LIGHT);
m_font.set_size(8 * PANGO_SCALE);
m_font.set_stretch(Pango::STRETCH_NORMAL);
set_size_request(-1, 25);
}
static gint
gail_text_cell_get_offset_at_point (AtkText *text,
gint x,
gint y,
AtkCoordType coords)
{
AtkObject *parent;
GailRendererCell *gail_renderer;
GtkCellRendererText *gtk_renderer;
GtkWidget *widget;
GdkRectangle rendered_rect;
PangoLayout *layout;
gint x_offset, y_offset, index;
if (!GAIL_TEXT_CELL (text)->cell_text)
return -1;
gail_renderer = GAIL_RENDERER_CELL (text);
gtk_renderer = GTK_CELL_RENDERER_TEXT (gail_renderer->renderer);
parent = atk_object_get_parent (ATK_OBJECT (text));
g_return_val_if_fail (gtk_renderer->text, -1);
if (GAIL_IS_CONTAINER_CELL (parent))
parent = atk_object_get_parent (parent);
widget = GTK_ACCESSIBLE (parent)->widget;
g_return_val_if_fail (GAIL_IS_CELL_PARENT (parent), -1);
gail_cell_parent_get_cell_area (GAIL_CELL_PARENT (parent), GAIL_CELL (text),
&rendered_rect);
gtk_cell_renderer_get_size (GTK_CELL_RENDERER (gtk_renderer), widget,
&rendered_rect, &x_offset, &y_offset, NULL, NULL);
layout = create_pango_layout (gtk_renderer, widget);
index = gail_misc_get_index_at_point_in_layout (widget, layout,
x_offset + rendered_rect.x + gail_renderer->renderer->xpad,
y_offset + rendered_rect.y + gail_renderer->renderer->ypad,
x, y, coords);
g_object_unref (layout);
if (index == -1)
{
if (coords == ATK_XY_WINDOW || coords == ATK_XY_SCREEN)
return g_utf8_strlen (gtk_renderer->text, -1);
return index;
}
else
return g_utf8_pointer_to_offset (gtk_renderer->text,
gtk_renderer->text + index);
}
void ListNode::draw_text(const Cairo::RefPtr<Cairo::Context> & cr, int x, int y) {
char * str = new char[10];
sprintf(str, "%d", data);
Pango::FontDescription font;
font.set_family("Monospace");
font.set_weight(Pango::WEIGHT_BOLD);
Glib::RefPtr<Pango::Layout> layout = create_pango_layout(str);
layout->set_font_description(font);
int text_w, text_h;
layout->get_pixel_size(text_w, text_h);
cr->move_to(x + (field_w - text_w) / 2, y + (field_h - text_h) / 2);
layout->show_in_cairo_context(cr);
}
static AtkAttributeSet *
gtk_text_cell_accessible_get_run_attributes (AtkText *text,
gint offset,
gint *start_offset,
gint *end_offset)
{
AtkAttributeSet *attrib_set = NULL;
PangoLayout *layout;
layout = create_pango_layout (GTK_TEXT_CELL_ACCESSIBLE (text));
attrib_set = _gtk_pango_get_run_attributes (NULL, layout, offset, start_offset, end_offset);
g_object_unref (G_OBJECT (layout));
return attrib_set;
}
static gchar *
gtk_text_cell_accessible_get_text_after_offset (AtkText *atk_text,
gint offset,
AtkTextBoundary boundary_type,
gint *start_offset,
gint *end_offset)
{
PangoLayout *layout;
gchar *text;
layout = create_pango_layout (GTK_TEXT_CELL_ACCESSIBLE (atk_text));
text = _gtk_pango_get_text_after (layout, boundary_type, offset, start_offset, end_offset);
g_object_unref (layout);
return text;
}
/**
Crea la capa en la que se pintara el histograma y tambien la capa para la escritura
con pango
*/
void PlotHistogram::creaCapaPlot()
{
if(surfacePlot)
{
surfacePlot->finish();
}
surfacePlot = Cairo::ImageSurface::create(Cairo::FORMAT_ARGB32, anchoPlot, altoPlot);
cr = Cairo::Context::create (surfacePlot);
cr->set_operator(Cairo::OPERATOR_SOURCE);
layout = create_pango_layout("");
set_size_request(anchoPlot, altoPlot);
}
static gchar *
gtk_icon_view_item_accessible_get_text_after_offset (AtkText *atk_text,
gint offset,
AtkTextBoundary boundary_type,
gint *start_offset,
gint *end_offset)
{
GtkIconViewItemAccessible *item;
PangoLayout *layout;
gchar *text;
item = GTK_ICON_VIEW_ITEM_ACCESSIBLE (atk_text);
if (atk_state_set_contains_state (item->state_set, ATK_STATE_DEFUNCT))
return NULL;
layout = create_pango_layout (item);
text = _gtk_pango_get_text_after (layout, boundary_type, offset, start_offset, end_offset);
g_object_unref (layout);
return text;
}
bool ClassificationCell::on_expose_event(GdkEventExpose *e)
{
char buf[10];
sprintf (buf, "%.0f", round(value));
// std::stringstream buf;
//buf.precision(0);
//buf.setf(std::ios::fixed, std::ios::floatfield);
int w=0, h=0;
Glib::RefPtr<Gdk::Window> window = get_window();
if (value > 50.0)
window->set_background(green);
else if (value > 25.0)
window->set_background(lightgreen);
else if (value > 0.05)
window->set_background(lightred);
else
window->set_background(white);
window->clear();
window->draw_rectangle(gc, false, 0, 0, 39, 29);
// buf << value;
// printf ("string %s\n", buf.str().c_str());
Glib::RefPtr<Pango::Layout> p = create_pango_layout(Glib::ustring(buf));
p->set_alignment(Pango::ALIGN_CENTER);
p->get_pixel_size(w, h);
int nx = (40-w) / 2 + 1;
int ny = (30-h) / 2 + 1;
window->draw_layout(gc, nx, ny, p);
window->invalidate_rect(Gdk::Rectangle(0,0,40,30), false);
return true;
}
static AtkAttributeSet *
gtk_text_cell_accessible_get_default_attributes (AtkText *text)
{
AtkAttributeSet *attrib_set = NULL;
PangoLayout *layout;
GtkWidget *widget;
layout = create_pango_layout (GTK_TEXT_CELL_ACCESSIBLE (text));
widget = get_widget (GTK_TEXT_CELL_ACCESSIBLE (text));
attrib_set = add_attribute (attrib_set, ATK_TEXT_ATTR_DIRECTION,
atk_text_attribute_get_value (ATK_TEXT_ATTR_DIRECTION,
gtk_widget_get_direction (widget)));
attrib_set = _gtk_pango_get_default_attributes (NULL, layout);
attrib_set = _gtk_style_context_get_attributes (attrib_set,
gtk_widget_get_style_context (widget),
gtk_widget_get_state_flags (widget));
g_object_unref (G_OBJECT (layout));
return attrib_set;
}
static gint
gtk_text_cell_accessible_get_offset_at_point (AtkText *text,
gint x,
gint y,
AtkCoordType coords)
{
AtkObject *parent;
GtkRendererCellAccessible *gail_renderer;
GtkCellRendererText *gtk_renderer;
GtkRequisition min_size;
GtkWidget *widget;
GdkRectangle rendered_rect;
PangoLayout *layout;
gchar *renderer_text;
gfloat xalign, yalign;
gint x_offset, y_offset, index;
gint xpad, ypad;
gint x_window, y_window, x_toplevel, y_toplevel;
gint x_temp, y_temp;
gboolean ret;
if (!GTK_TEXT_CELL_ACCESSIBLE (text)->cell_text)
return -1;
gail_renderer = GTK_RENDERER_CELL_ACCESSIBLE (text);
gtk_renderer = GTK_CELL_RENDERER_TEXT (gail_renderer->renderer);
parent = atk_object_get_parent (ATK_OBJECT (text));
g_object_get (gtk_renderer, "text", &renderer_text, NULL);
if (text == NULL)
{
g_free (renderer_text);
return -1;
}
if (GTK_IS_CONTAINER_CELL_ACCESSIBLE (parent))
parent = atk_object_get_parent (parent);
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (parent));
g_return_val_if_fail (GTK_IS_CELL_ACCESSIBLE_PARENT (parent), -1);
_gtk_cell_accessible_parent_get_cell_area (GTK_CELL_ACCESSIBLE_PARENT (parent),
GTK_CELL_ACCESSIBLE (text),
&rendered_rect);
gtk_cell_renderer_get_preferred_size (GTK_CELL_RENDERER (gtk_renderer),
widget,
&min_size, NULL);
gtk_cell_renderer_get_alignment (GTK_CELL_RENDERER (gtk_renderer), &xalign, &yalign);
if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
xalign = 1.0 - xalign;
x_offset = MAX (0, xalign * (rendered_rect.width - min_size.width));
y_offset = MAX (0, yalign * (rendered_rect.height - min_size.height));
layout = create_pango_layout (GTK_TEXT_CELL_ACCESSIBLE (text));
gtk_cell_renderer_get_padding (gail_renderer->renderer, &xpad, &ypad);
get_origins (widget, &x_window, &y_window, &x_toplevel, &y_toplevel);
x_temp = x - (x_offset + rendered_rect.x + xpad) - x_window;
y_temp = y - (y_offset + rendered_rect.y + ypad) - y_window;
if (coords == ATK_XY_WINDOW)
{
x_temp += x_toplevel;
y_temp += y_toplevel;
}
else if (coords != ATK_XY_SCREEN)
index = -1;
ret = pango_layout_xy_to_index (layout,
x_temp * PANGO_SCALE,
y_temp * PANGO_SCALE,
&index, NULL);
if (!ret)
{
if (x_temp < 0 || y_temp < 0)
index = 0;
else
index = -1;
}
g_object_unref (layout);
if (index == -1)
{
if (coords == ATK_XY_WINDOW || coords == ATK_XY_SCREEN)
{
glong length;
length = g_utf8_strlen (renderer_text, -1);
g_free (renderer_text);
return length;
}
g_free (renderer_text);
return index;
}
else
{
glong offset;
offset = g_utf8_pointer_to_offset (renderer_text,
renderer_text + index);
g_free (renderer_text);
return offset;
}
}
static void
gtk_text_cell_accessible_get_character_extents (AtkText *text,
gint offset,
gint *x,
gint *y,
gint *width,
gint *height,
AtkCoordType coords)
{
GtkRendererCellAccessible *gail_renderer;
GtkRequisition min_size;
GtkCellRendererText *gtk_renderer;
GdkRectangle rendered_rect;
GtkWidget *widget;
AtkObject *parent;
PangoRectangle char_rect;
PangoLayout *layout;
gchar *renderer_text;
gfloat xalign, yalign;
gint x_offset, y_offset, index;
gint xpad, ypad;
gint x_window, y_window, x_toplevel, y_toplevel;
if (!GTK_TEXT_CELL_ACCESSIBLE (text)->cell_text)
{
*x = *y = *height = *width = 0;
return;
}
if (offset < 0 || offset >= GTK_TEXT_CELL_ACCESSIBLE (text)->cell_length)
{
*x = *y = *height = *width = 0;
return;
}
gail_renderer = GTK_RENDERER_CELL_ACCESSIBLE (text);
gtk_renderer = GTK_CELL_RENDERER_TEXT (gail_renderer->renderer);
g_object_get (gtk_renderer, "text", &renderer_text, NULL);
if (text == NULL)
{
g_free (renderer_text);
return;
}
parent = atk_object_get_parent (ATK_OBJECT (text));
if (GTK_IS_CONTAINER_CELL_ACCESSIBLE (parent))
parent = atk_object_get_parent (parent);
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (parent));
g_return_if_fail (GTK_IS_CELL_ACCESSIBLE_PARENT (parent));
_gtk_cell_accessible_parent_get_cell_area (GTK_CELL_ACCESSIBLE_PARENT (parent),
GTK_CELL_ACCESSIBLE (text),
&rendered_rect);
gtk_cell_renderer_get_preferred_size (GTK_CELL_RENDERER (gtk_renderer),
widget,
&min_size, NULL);
gtk_cell_renderer_get_alignment (GTK_CELL_RENDERER (gtk_renderer), &xalign, &yalign);
if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
xalign = 1.0 - xalign;
x_offset = MAX (0, xalign * (rendered_rect.width - min_size.width));
y_offset = MAX (0, yalign * (rendered_rect.height - min_size.height));
layout = create_pango_layout (GTK_TEXT_CELL_ACCESSIBLE (text));
index = g_utf8_offset_to_pointer (renderer_text, offset) - renderer_text;
pango_layout_index_to_pos (layout, index, &char_rect);
gtk_cell_renderer_get_padding (gail_renderer->renderer, &xpad, &ypad);
get_origins (widget, &x_window, &y_window, &x_toplevel, &y_toplevel);
*x = (char_rect.x / PANGO_SCALE) + x_offset + rendered_rect.x + xpad + x_window;
*y = (char_rect.y / PANGO_SCALE) + y_offset + rendered_rect.y + ypad + y_window;
*height = char_rect.height / PANGO_SCALE;
*width = char_rect.width / PANGO_SCALE;
if (coords == ATK_XY_WINDOW)
{
*x -= x_toplevel;
*y -= y_toplevel;
}
else if (coords != ATK_XY_SCREEN)
{
*x = 0;
*y = 0;
*height = 0;
*width = 0;
}
g_free (renderer_text);
g_object_unref (layout);
}
/**
* Render the Preview
* @param Cairo::Context cr
* @return Gtk::Window::on_draw(cr)
*/
bool Preview::on_draw(const Cairo::RefPtr<Cairo::Context>& cr)
{
Configuration::Theme theme = Configuration::getTheme();
if (theme.forPreview().enabled()) {
cr->set_source_rgba(
theme.forPreview().background().red,
theme.forPreview().background().green,
theme.forPreview().background().blue,
theme.forPreview().background().alpha);
Utilities::RoundedRectangle(cr, 0, 0, this->get_width(), this->get_height(),
theme.forPreview().roundedRatious());
cr->fill();
}
if (!m_isActive) {
return Gtk::Window::on_draw(cr);
}
if (m_previewtems.size() < 1) {
this->hideMe();
return Gtk::Window::on_draw(cr);
}
int idx = 0;
for (DockItem* item : m_previewtems) {
if (item->m_window == NULL || item->m_xid == 0 || !item->visible)
continue;
int pos_x = 20 + (m_previewWidth * idx);
int pos_y = 16;
int pos_width = m_previewWidth - DEF_PREVIEW_LEFT_MARGING;
int pos_height = 20;
cr->set_source_rgba(
theme.forPreview().foreground().red,
theme.forPreview().foreground().green,
theme.forPreview().foreground().blue,
theme.forPreview().foreground().alpha);
cr->set_line_width(theme.forPreview().lineWith());
if (item->m_imageLoadedRequired)
cr->set_line_width(theme.forPreview().lineWith() + 0.5);
if (theme.getPreviewBinaryValue() == 0) {
Utilities::RoundedRectangle(cr,
DEF_PREVIEW_LEFT_MARGING + (m_previewWidth * idx),
16, m_previewWidth,
m_previewHeight - DEF_PREVIEW_RIGHT_MARGING,
theme.forPreview().roundedRatious());
cr->stroke();
} else {
cr->set_line_width(theme.forPreview().lineWith());
int pos_x = DEF_PREVIEW_LEFT_MARGING + (m_previewWidth * idx);
int y_pos = 16;
int width = m_previewWidth;
int height = m_previewHeight;
int value = theme.getPreviewBinaryValue();
/* Vertical Left*/
int bit = CHECK_BIT(value, 3);
if (bit == 1) {
cr->set_line_width(theme.forPreview().lineWith());
cr->move_to(pos_x, y_pos);
cr->line_to(pos_x, y_pos);
cr->line_to(pos_x, y_pos + (m_previewHeight - DEF_PREVIEW_RIGHT_MARGING));
cr->stroke();
}
/* Top */
bit = CHECK_BIT(value, 2);
if (bit == 1) {
cr->set_line_width(theme.forPreview().lineWith());
cr->move_to(pos_x, y_pos);
cr->line_to(pos_x, y_pos);
cr->line_to(pos_x + (m_previewWidth), y_pos);
cr->stroke();
}
/* Right vertical */
bit = CHECK_BIT(value, 1);
if (bit == 1) {
cr->set_line_width(theme.forPreview().lineWith());
cr->move_to(pos_x + m_previewWidth, y_pos);
cr->line_to(pos_x + m_previewWidth, y_pos);
cr->line_to(pos_x + m_previewWidth, y_pos + (m_previewHeight - DEF_PREVIEW_RIGHT_MARGING));
cr->stroke();
}
bit = CHECK_BIT(value, 0);
if (bit == 1) {
cr->set_line_width(theme.forPreview().lineWith());
cr->move_to(pos_x, y_pos + (m_previewHeight - DEF_PREVIEW_RIGHT_MARGING));
cr->line_to(pos_x, y_pos + (m_previewHeight - DEF_PREVIEW_RIGHT_MARGING));
cr->line_to(pos_x + m_previewWidth, y_pos + (m_previewHeight - DEF_PREVIEW_RIGHT_MARGING));
cr->stroke();
}
}
// TEXT
// draw title and create clipping rectangle
// JG
cr->set_source_rgba(
theme.forPreviewTitle().background().red,
theme.forPreviewTitle().background().green,
theme.forPreviewTitle().background().blue,
theme.forPreviewTitle().foreground().alpha);
cr->rectangle(pos_x, pos_y + 2, pos_width + 2, pos_height);
// cr->clip_preserve();
cr->fill();
// JG
cr->set_source_rgba(
theme.forPreviewTitle().foreground().red,
theme.forPreviewTitle().foreground().green,
theme.forPreviewTitle().foreground().blue,
theme.forPreviewTitle().foreground().alpha);
cr->set_line_width(theme.forPreviewTitle().lineWith());
cr->rectangle(pos_x, pos_y + 2, pos_width + 2, pos_height);
cr->stroke();
// draw title the clipping rectangle
//cr->set_source_rgba(1.0, 1.0, 1.0, 0.0);
cr->rectangle(pos_x, pos_y + 2, pos_width, pos_height);
cr->clip_preserve();
cr->stroke();
cr->set_source_rgba(
theme.forPreviewTitleText().foreground().red,
theme.forPreviewTitleText().foreground().green,
theme.forPreviewTitleText().foreground().blue,
theme.forPreviewTitleText().foreground().alpha);
auto layout = create_pango_layout(item->m_titlename);
layout->set_font_description(font);
//cr->set_source_rgba(1.0, 1.0, 1.0, 1.0); // white text
cr->move_to(pos_x, pos_y + 2);
layout->show_in_cairo_context(cr);
cr->reset_clip(); // Reset the clipping
if (item->m_imageLoadedRequired) {
GdkPixbuf *scaledpb = getScaledPixbuf(item);
if (scaledpb == nullptr) {
continue;
}
// show the loaded image.
showPreview(cr, scaledpb, idx);
// Checks if the image have movement.
if (item->isMovementDetected(scaledpb) && !item->m_isDynamic) {
item->m_isDynamic = true;
}
// if no movement has been detected, means that the image
// is static and we don't need to reload it again
if (++item->m_frames > 3 && !item->m_isDynamic) {
item->m_scaledPixbuf = scaledpb;
item->m_frames = 0;
item->m_imageLoadedRequired = false;
}
// if the image is static do not unreference the scaledpb.
if (item->m_imageLoadedRequired)
g_object_unref(scaledpb);
} else {
// show the loaded static image.
showPreview(cr, item->m_scaledPixbuf, idx);
}
// selector
if (m_currentIndex == idx) {
// rectangle background selector
pos_x = DEF_PREVIEW_LEFT_MARGING + (m_previewWidth * m_currentIndex);
pos_y = 16;
pos_width = m_previewWidth + 1;
pos_height = m_previewHeight - DEF_PREVIEW_RIGHT_MARGING;
if (m_previewtems.size() > 1) {
cr->set_source_rgba(
theme.forPreviewSelector().background().red,
theme.forPreviewSelector().background().green,
theme.forPreviewSelector().background().blue,
theme.forPreviewSelector().background().alpha);
Utilities::RoundedRectangle(cr, pos_x, pos_y, pos_width, pos_height,
theme.forPreviewSelector().roundedRatious());
cr->fill();
}
cr->set_source_rgba(
theme.forPreviewSelector().foreground().red,
theme.forPreviewSelector().foreground().green,
theme.forPreviewSelector().foreground().blue,
theme.forPreviewSelector().foreground().alpha);
cr->set_line_width(theme.forPreviewSelector().lineWith());
if (theme.getPreviewSelectorBinaryValue() == 0) {
Utilities::RoundedRectangle(cr, pos_x, pos_y, pos_width, pos_height,
theme.forPreviewSelector().roundedRatious());
cr->stroke();
} else {
int value = theme.getPreviewSelectorBinaryValue();
// /* Vertical Left*/
int bit = CHECK_BIT(value, 3);
if (bit == 1) {
cr->move_to(pos_x, pos_y);
cr->line_to(pos_x, pos_y);
cr->line_to(pos_x, pos_y + (pos_height));
cr->stroke();
}
/* Top */
bit = CHECK_BIT(value, 2);
if (bit == 1) {
cr->move_to(pos_x, pos_y);
cr->line_to(pos_x, pos_y);
cr->line_to(pos_x + (pos_width), pos_y);
cr->stroke();
}
/* Right vertical */
bit = CHECK_BIT(value, 1);
if (bit == 1) {
cr->move_to(pos_x + pos_width, pos_y);
cr->line_to(pos_x + pos_width, pos_y);
cr->line_to(pos_x + pos_width, pos_y + (m_previewHeight - DEF_PREVIEW_RIGHT_MARGING));
cr->stroke();
}
bit = CHECK_BIT(value, 0);
if (bit == 1) {
cr->move_to(pos_x, pos_y + (m_previewHeight - DEF_PREVIEW_RIGHT_MARGING));
cr->line_to(pos_x, pos_y + (m_previewHeight - DEF_PREVIEW_RIGHT_MARGING));
cr->line_to(pos_x + m_previewWidth, pos_y + (m_previewHeight - DEF_PREVIEW_RIGHT_MARGING));
cr->stroke();
}
}
cr->set_source_rgba(
theme.forPreviewSelectorClose().background().red,
theme.forPreviewSelectorClose().background().green,
theme.forPreviewSelectorClose().background().blue,
theme.forPreviewSelectorClose().background().alpha);
pos_x = (m_previewWidth - 5) + (m_previewWidth * m_currentIndex);
cr->move_to(pos_x + 3, DEF_PREVIEW_RIGHT_MARGING);
cr->rectangle(pos_x, 18, DEF_PREVIEW_LEFT_MARGING, DEF_PREVIEW_LEFT_MARGING + 2);
cr->fill();
cr->set_source_rgba(
theme.forPreviewSelectorClose().foreground().red,
theme.forPreviewSelectorClose().foreground().green,
theme.forPreviewSelectorClose().foreground().blue,
theme.forPreviewSelectorClose().foreground().alpha);
cr->set_line_width(theme.forPreviewSelectorClose().lineWith());
// Close X text
cr->move_to(pos_x + 3, DEF_PREVIEW_RIGHT_MARGING - 1);
cr->show_text("X");
}
idx++;
}
return Gtk::Window::on_draw(cr);
}
