Esempio n. 1
0
File: adcap.c Progetto: athurg/adcap
G_MODULE_EXPORT
void btn_save_cb(GtkButton *btn, gpointer data)
{
	cairo_t *cr;
	cairo_surface_t *surface;
	int i;
	double y;

	surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 512, 500);
	cr = cairo_create (surface);

	paint_bg(cr);
	paint_marker(cr);

	//画图(蓝色)
	cairo_set_line_width(cr, 1);
	cairo_set_source_rgb(cr, 0, 0, 1);
	y = TOY(buffer[0])>500 ? 500 : TOY(buffer[0]);
	cairo_move_to(cr, 0, TOY(buffer[0]));
	for (i=1; i<512; i++) {
		y = cfg.yref + yscale*TOY(buffer[i-1]);
		//cairo_line_to(cr, i-1, cfg.yref+yscale*TOY(buffer[i-1]));
		cairo_line_to(cr, i-1, y>500?500:y);
	}
	cairo_stroke(cr);

	cairo_surface_write_to_png(surface, "save.png");

	cairo_destroy(cr);
	cairo_surface_destroy(surface);
}
Esempio n. 2
0
File: adcap.c Progetto: athurg/adcap
/**
	 根据共享数组,刷新显示
  */
G_MODULE_EXPORT
int paint(GtkWidget *widget, GdkEvent *event, gpointer data)
{
	cairo_t *cr;
	int i;
	double y;

	cr = gdk_cairo_create (widget->window);

	paint_bg(cr);

	//画图(蓝色)
	cairo_set_line_width(cr, 1);
	cairo_set_source_rgb(cr, 0, 0, 1);
	y = TOY(buffer[0])>500 ? 500 : TOY(buffer[0]);
	cairo_move_to(cr, 0, TOY(buffer[0]));
	for (i=1; i<512; i++) {
		//y轴分为10个div,每个div包含50个点
		//因此每1dBm对应的y坐标应该为50/ydiv
		//y = (cfg.yref+buffer[i-1]);//dBm值
		//y *= -1*50/cfg.ydiv;//坐标值
		y = power2axis(buffer[i-1]);
		cairo_line_to(cr, i-1, y>500?500:y);
	}
	cairo_stroke(cr);

	paint_marker(cr);
	cairo_destroy(cr);
	return TRUE;
}
void UberDelegate::paint_labor(const QRect &adjusted, QPainter *p, const QStyleOptionViewItem &opt, const QModelIndex &proxy_idx) const {
    QModelIndex idx = m_proxy->mapToSource(proxy_idx);
    short rating = idx.data(DwarfModel::DR_RATING).toInt();

    Dwarf *d = m_model->get_dwarf_by_id(idx.data(DwarfModel::DR_ID).toInt());
    if (!d) {
        return QStyledItemDelegate::paint(p, opt, idx);
    }

    int labor_id = idx.data(DwarfModel::DR_LABOR_ID).toInt();
    bool enabled = d->labor_enabled(labor_id);
    bool dirty = d->is_labor_state_dirty(labor_id);

    QColor bg = paint_bg(adjusted, enabled, p, opt, proxy_idx);
    paint_skill(adjusted, rating, bg, p, opt, proxy_idx);
    paint_grid(adjusted, dirty, p, opt, proxy_idx);
}
void UberDelegate::paint_pref(const QRect &adjusted, QPainter *p, const QStyleOptionViewItem &opt, const QModelIndex &proxy_idx) const {
    QModelIndex idx = m_proxy->mapToSource(proxy_idx);
    Dwarf *d = m_model->get_dwarf_by_id(idx.data(DwarfModel::DR_ID).toInt());
    if (!d) {
        return QStyledItemDelegate::paint(p, opt, idx);
    }

    int labor_id = idx.data(DwarfModel::DR_LABOR_ID).toInt();
    short val = d->pref_value(labor_id);
    QString symbol = GameDataReader::ptr()->get_military_preference(labor_id)->value_symbol(val);
    bool dirty = d->is_labor_state_dirty(labor_id);

    QColor bg = paint_bg(adjusted, false, p, opt, proxy_idx);
    p->save();
    if (auto_contrast)
        p->setPen(QPen(compliment(bg)));
    p->drawText(opt.rect, Qt::AlignCenter, symbol);
    p->restore();
    paint_grid(adjusted, dirty, p, opt, proxy_idx);
}
Esempio n. 5
0
void UberDelegate::paint_cell(QPainter *p, const QStyleOptionViewItem &opt, const QModelIndex &idx, const bool drawing_aggregate) const {
    QModelIndex model_idx = idx;
    if (m_proxy)
        model_idx = m_proxy->mapToSource(idx);

    COLUMN_TYPE type = static_cast<COLUMN_TYPE>(model_idx.data(DwarfModel::DR_COL_TYPE).toInt());
    QRect adjusted = opt.rect.adjusted(cell_padding, cell_padding, -cell_padding, -cell_padding);

    float rating = model_idx.data(DwarfModel::DR_RATING).toFloat();
    QString text_rating = model_idx.data(DwarfModel::DR_DISPLAY_RATING).toString();
    float limit = 100.0;

    switch (type) {
    case CT_SKILL:
    {
        QColor bg = paint_bg(adjusted, p, opt, idx);
        limit = 15.0;
        if(rating >= 0)
            paint_values(adjusted, rating, text_rating, bg, p, opt, idx, 0, 0, limit, 0, 0);

        paint_mood_cell(adjusted,p,opt,idx,model_idx.data(DwarfModel::DR_SKILL_ID).toInt(),false);
    }
        break;
    case CT_LABOR:
    {
        if (!drawing_aggregate) {
            Dwarf *d = m_model->get_dwarf_by_id(idx.data(DwarfModel::DR_ID).toInt());
            if (!d) {
                return QStyledItemDelegate::paint(p, opt, idx);
            }
            int labor_id = idx.data(DwarfModel::DR_LABOR_ID).toInt();
            bool enabled = d->labor_enabled(labor_id);
            bool dirty = d->is_labor_state_dirty(labor_id);

            QColor bg = paint_bg_active(adjusted, enabled, p, opt, idx);
            limit = 15.0;
            if(rating >= 0)
                paint_values(adjusted, rating, text_rating, bg, p, opt, idx, 0, 0, limit, 0, 0);

            paint_mood_cell(adjusted,p,opt,idx,GameDataReader::ptr()->get_labor(labor_id)->skill_id, dirty);
        }else {
            paint_labor_aggregate(adjusted, p, opt, idx);
        }
    }
        break;
    case CT_HAPPINESS:
    {
        paint_bg(adjusted, p, opt, idx, true, model_idx.data(Qt::BackgroundColorRole).value<QColor>());
        if(draw_happiness_icons){
            paint_icon(adjusted,p,opt,idx);
        }else{
            p->save();
            paint_grid(adjusted, false, p, opt, idx);
            p->restore();
        }
    }
        break;
    case CT_EQUIPMENT:
    {
        int wear_level = idx.data(DwarfModel::DR_SPECIAL_FLAG).toInt();
        paint_bg(adjusted, p, opt, idx, true, model_idx.data(Qt::BackgroundColorRole).value<QColor>());
        paint_wear_cell(adjusted,p,opt,idx,wear_level);
    }
        break;
    case CT_ITEMTYPE:
    {
        QColor bg = paint_bg(adjusted, p, opt, idx, true, model_idx.data(Qt::BackgroundColorRole).value<QColor>());
        //if we're drawing numbers, we only want to draw counts for squads
        //this is a special case because we're drawing different information if it's text mode
        if(m_skill_drawing_method == SDM_NUMERIC && rating == 100)
            rating = -1;
        paint_values(adjusted, rating, text_rating, bg, p, opt, idx,90.0f,5.0f,95.0f,99.99f,102.0f,false);
        int wear_level = idx.data(DwarfModel::DR_SPECIAL_FLAG).toInt();
        paint_wear_cell(adjusted,p,opt,idx,wear_level);
    }
        break;
    case CT_ROLE:
    {
        bool active_labors = false;
        int dirty_alpha = 255;
        int active_alpha = 255;
        bool dirty = false;
        Dwarf *d = m_model->get_dwarf_by_id(idx.data(DwarfModel::DR_ID).toInt());
        if(d){
            if(idx.data(DwarfModel::DR_SPECIAL_FLAG).canConvert<QVariantList>()){
                QVariantList labors = idx.data(DwarfModel::DR_SPECIAL_FLAG).toList();
                int active_count = 0;
                int dirty_count = 0;
                foreach(QVariant id, labors){
                    if(d->labor_enabled(id.toInt())){
                        active_labors = true;
                        active_count++;
                    }
                    if(d->is_labor_state_dirty(id.toInt())){
                        dirty = true;
                        dirty_count++;
                    }
                }
                if(active_labors)
                    active_alpha = (255 * ((float)active_count / labors.count()));
                if(dirty)
                    dirty_alpha = (255 * ((float)dirty_count / labors.count()));                                
            }
        }
        QColor bg;
        QColor color_active_adjusted = color_active_labor;
        if(active_labors){
            color_active_adjusted.setAlpha(active_alpha);
            bg = paint_bg_active(adjusted, active_labors, p, opt, idx, color_active_adjusted);
        }else{
            bg = paint_bg(adjusted, p, opt, idx);
        }
        double limit_range = (DwarfStats::get_role_max() - DwarfStats::get_role_min()) * 0.05;
        paint_values(adjusted, rating, text_rating, bg, p, opt, idx,50.0f, DwarfStats::get_role_min() + limit_range,DwarfStats::get_role_max() - limit_range,45.0f,55.0f);
        if(dirty){
            QColor color_dirty_adjusted = color_dirty_border;
            color_dirty_adjusted.setAlpha(dirty_alpha);
            paint_border(adjusted,p,color_dirty_adjusted);
            paint_grid(adjusted,false,p,opt,idx,false);
        }else{
            paint_grid(adjusted, dirty, p, opt, idx);
        }
    }
        break;
    case CT_IDLE:
    {
        paint_bg(adjusted, p, opt, idx, true, model_idx.data(Qt::BackgroundColorRole).value<QColor>());
        paint_icon(adjusted,p,opt,idx);
    }
        break;
    case CT_PROFESSION:
    {
        paint_bg(adjusted, p, opt, idx, true, model_idx.data(Qt::BackgroundColorRole).value<QColor>());
        paint_icon(adjusted,p,opt,idx);
    }
        break;
    case CT_HIGHEST_MOOD:
    {
        paint_bg(adjusted, p, opt, idx, true, model_idx.data(Qt::BackgroundColorRole).value<QColor>());
        paint_icon(adjusted,p,opt,idx);

        bool had_mood = idx.data(DwarfModel::DR_SPECIAL_FLAG).toBool();
        if(had_mood){
            p->save();
            QRect moodr = adjusted;
            moodr.adjust(2,2,-2,-2);
            p->setPen(QPen(Qt::darkRed,2));
            p->drawLine(moodr.bottomLeft(), moodr.topRight());
            p->restore();
        }
    }
        break;
    case CT_TRAIT:
    {
        QColor bg = paint_bg(adjusted, p, opt, idx);
        paint_values(adjusted, rating, text_rating, bg, p, opt, idx, 50, 10, 90);
        paint_grid(adjusted, false, p, opt, idx);
    }
        break;
    case CT_ATTRIBUTE:
    {
        QColor bg = paint_bg(adjusted, p, opt, idx);
        paint_values(adjusted, rating, text_rating, bg, p, opt, idx, 50.0f, 2.0f, 98.0f);

        if(color_attribute_syns && idx.data(DwarfModel::DR_SPECIAL_FLAG).toInt() > 0){
            paint_border(adjusted,p,Attribute::color_affected_by_syns());
            paint_grid(adjusted, false, p, opt, idx, false);
        }else{
            paint_grid(adjusted, false, p, opt, idx);
        }
    }
        break;
    case CT_WEAPON:
    {
        QColor bg = paint_bg(adjusted, p, opt, idx);
        paint_values(adjusted, rating, text_rating, bg, p, opt, idx, 50.0f, 1, 99, 49, 51, true);
        paint_grid(adjusted, false, p, opt, idx);

    }
        break;
    case CT_FLAGS:
    {
        paint_flags(adjusted, p, opt, idx);
    }
        break;
    case CT_TRAINED:
    {
        QColor bg = paint_bg(adjusted, p, opt, idx, false, model_idx.data(Qt::BackgroundColorRole).value<QColor>());
        //arbitrary ignore range is used just to hide tame animals
        paint_values(adjusted, rating, text_rating, bg, p, opt, idx, 50.0f, 1.0f, 95.0f, 49.9f, 50.1f, true);
        paint_grid(adjusted, false, p, opt, idx);
    }
        break;
    case CT_HEALTH:
    {
        QColor bg = paint_bg(adjusted, p, opt, idx, false, model_idx.data(Qt::BackgroundColorRole).value<QColor>());

        //draw the symbol text in bold
        p->save();
        if (rating != 0) {
            if(color_health_cells){
                p->setPen(model_idx.data(Qt::TextColorRole).value<QColor>());
            }else{
                if(auto_contrast){
                    p->setPen(compliment(bg));
                }else{
                    p->setPen(Qt::black);
                }
            }

            QFont tmp = m_fnt;
            tmp.setBold(true);
            p->setFont(tmp);
            p->drawText(opt.rect, Qt::AlignCenter, text_rating);
        }
        p->restore();

        paint_grid(adjusted, false, p, opt, idx);
    }
        break;
    case CT_SPACER:
    case CT_DEFAULT:
    default:
    {
        if(adjusted.width() > 0)
            paint_bg(adjusted, p, opt, idx, true, model_idx.data(Qt::BackgroundColorRole).value<QColor>());
        break;
    }
    }
void UberDelegate::paint_cell(QPainter *p, const QStyleOptionViewItem &opt, const QModelIndex &idx) const {
    QModelIndex model_idx = idx;
    if (m_proxy)
        model_idx = m_proxy->mapToSource(idx);

    COLUMN_TYPE type = static_cast<COLUMN_TYPE>(model_idx.data(DwarfModel::DR_COL_TYPE).toInt());
    QRect adjusted = opt.rect.adjusted(cell_padding, cell_padding, (cell_padding * -2) - 1, (cell_padding * -2) - 1);
    switch (type) {
        case CT_SKILL:
            {
                short rating = model_idx.data(DwarfModel::DR_RATING).toInt();
                QColor bg = paint_bg(adjusted, false, p, opt, idx);
                paint_skill(adjusted, rating, bg, p, opt, idx);
                paint_grid(adjusted, false, p, opt, idx);
            }
            break;
        case CT_LABOR:
            {
                bool agg = model_idx.data(DwarfModel::DR_IS_AGGREGATE).toBool();
                if (m_model->current_grouping() == DwarfModel::GB_NOTHING || !agg) {
                    paint_labor(adjusted, p, opt, idx);
                } else {
                    if (draw_aggregates)
                        paint_aggregate(adjusted, p, opt, idx);
                }
            }
            break;
        case CT_HAPPINESS:
            {
                paint_bg(adjusted, false, p, opt, idx);
                p->save();
                p->fillRect(adjusted, model_idx.data(Qt::BackgroundColorRole).value<QColor>());
                p->restore();
                paint_grid(adjusted, false, p, opt, idx);
            }
            break;
        case CT_IDLE:
            {
                paint_bg(adjusted, false, p, opt, idx);
                QIcon icon = idx.data(Qt::DecorationRole).value<QIcon>();
                QPixmap pixmap = icon.pixmap(adjusted.size());
                p->save();
                p->drawPixmap(adjusted, pixmap);
                p->restore();
                paint_grid(adjusted, false, p, opt, idx);
            }
            break;
        case CT_TRAIT:
        case CT_ATTRIBUTE:
            {
                paint_bg(adjusted, false, p, opt, idx);
                p->save();
                p->drawText(adjusted, Qt::AlignCenter, model_idx.data(Qt::DisplayRole).toString());
                p->restore();
                paint_grid(adjusted, false, p, opt, idx);
            }
            break;
        case CT_MILITARY_PREFERENCE:
            {
                bool agg = model_idx.data(DwarfModel::DR_IS_AGGREGATE).toBool();
                if (m_model->current_grouping() == DwarfModel::GB_NOTHING || !agg) {
                   paint_pref(adjusted, p, opt, idx);
                } else {
                    if (draw_aggregates)
                        paint_aggregate(adjusted, p, opt, idx);
                }
            }
            break;
        case CT_DEFAULT:
        case CT_SPACER:
        default:
            paint_bg(adjusted, false, p, opt, idx);
            //QStyledItemDelegate::paint(p, opt, idx);
            if (opt.state & QStyle::State_Selected) {
                p->save();
                p->setPen(color_guides);
                p->drawLine(opt.rect.topLeft(), opt.rect.topRight());
                p->drawLine(opt.rect.bottomLeft(), opt.rect.bottomRight());
                p->restore();
            }
            break;
    }
}