QVariant DiveTripModel::headerData(int section, Qt::Orientation orientation, int role) const { QVariant ret; if (orientation == Qt::Vertical) return ret; switch(role){ case Qt::FontRole : ret = defaultModelFont(); break; case Qt::DisplayRole : switch (section) { case NR: ret = tr("#"); break; case DATE: ret = tr("Date"); break; case RATING: ret = UTF8_BLACKSTAR; break; case DEPTH: ret = (get_units()->length == units::METERS) ? tr("m") : tr("ft"); break; case DURATION: ret = tr("min"); break; case TEMPERATURE:ret = QString("%1%2").arg(UTF8_DEGREE).arg((get_units()->temperature == units::CELSIUS) ? "C" : "F"); break; case TOTALWEIGHT:ret = (get_units()->weight == units::KG) ? tr("kg") : tr("lbs"); break; case SUIT: ret = tr("Suit"); break; case CYLINDER: ret = tr("Cyl"); break; case NITROX: ret = QString("O%1%").arg(UTF8_SUBSCRIPT_2); break; case SAC: ret = tr("SAC"); break; case OTU: ret = tr("OTU"); break; case MAXCNS: ret = tr("maxCNS"); break; case LOCATION: ret = tr("Location"); break; }break; } return ret; }
int main(int argc, char *argv[]) { char variable[10]; char cdf_name[200]; char *units; float X, Y, Z; int count = 0; float n; float missing = -10000.0; float delta_x, delta_y, delta_z; float interp_value1, sample_factor, x2; if (argc != 8) { printf("ERROR:this example program requires 7 arguments - (1)full path and file name of data file (2) VARIABLE NAME (3) x1 position (4) y1 position (5) z1 position (6) delta x (7) x2 \n"); exit( EXIT_FAILURE); } strcpy(cdf_name, argv[1]); strcpy(variable, argv[2]); X = atof(argv[3]); Y = atof(argv[4]); Z = atof(argv[5]); sample_factor = atof(argv[6]); x2 = atof(argv[7]); open_cdf(cdf_name, 0); /************************** example for new get_units() function *************************** ** takes variable name as argument and return a pointer to the string of units ** *******************************************************************************************/ units = get_units(variable); printf("units for %s = %s\n", variable, units); for (n = X; n <= x2; n+=sample_factor) { interp_value1 = interpolate_batsrus_cdf(variable, n, Y, Z, 0, 1, missing, &delta_x, &delta_y, &delta_z); printf("\t%s [ %f, %f, %f ]\t%g %s\tdelta %f %s\n", variable, n, Y, Z, interp_value1, get_units(variable), delta_x, get_units("x") ); count++; } close_cdf(); return 1; }
QString DiveItem::displayDepth() const { const int scale = 1000; QString fract, str; if (get_units()->length == units::METERS) { fract = QString::number((unsigned)(dive->maxdepth.mm % scale) / 100); str = QString("%1.%2").arg((unsigned)(dive->maxdepth.mm / scale)).arg(fract, 1, QChar('0')); } if (get_units()->length == units::FEET) { str = QString::number(mm_to_feet(dive->maxdepth.mm),'f',0); } return str; }
static int open(struct widget *w) { struct widget_priv *priv; priv = (struct widget_priv*) widget_malloc(sizeof(struct widget_priv)); if (priv == NULL) return -1; w->priv = priv; priv->home = get_home_data(); switch (get_units(w->cfg)) { case UNITS_METRIC: default: priv->range = 20*5; break; case UNITS_IMPERIAL: priv->range = 100*5; break; } add_mavlink_callback(MAVLINK_MSG_ID_GPS_RAW_INT, mav_callback, CALLBACK_WIDGET, w); w->ca.width = X_SIZE; w->ca.height = Y_SIZE; return 0; }
static void mav_callback(mavlink_message_t *msg, mavlink_status_t *status, void *d) { struct widget *w = d; struct widget_priv *priv = w->priv; float altitude; switch (w->cfg->props.mode) { case 0: default: altitude = mavlink_msg_gps_raw_int_get_alt(msg) / 1000.0; break; case 1: if (priv->home->lock == HOME_LOCKED) altitude = (long) priv->home->altitude; else altitude = 0; break; } if (get_units(w->cfg) == UNITS_IMPERIAL) altitude *= M2FEET; priv->altitude = (long) altitude; schedule_widget(w); }
double get_volume_units(unsigned int ml, int *frac, const char **units) { int decimals; double vol; const char *unit; struct units *units_p = get_units(); switch (units_p->volume) { case LITER: vol = ml / 1000.0; unit = _("l"); decimals = 1; break; case CUFT: vol = ml_to_cuft(ml); unit = _("cuft"); decimals = 2; break; } if (frac) *frac = decimals; if (units) *units = unit; return vol; }
static void render(struct widget *w) { struct widget_priv *priv = w->priv; struct canvas *ca = &w->ca; char buf[10]; struct point uav_points[4] = { {0, 0}, {6, 8}, {0, -8}, {-6, 8} }; struct polygon uav = { .len = 4, .points = uav_points, }; struct point arrow_points[7] = { {1, -10}, {1, -3}, {4, -4}, {0, 0}, {-4, -4}, {-1, -3}, {-1, -10} }; struct polygon arrow = { .len = 7, .points = arrow_points, }; move_polygon(&uav, ca->width >> 1, ca->height >> 1); draw_polygon(&uav, 3, ca); move_polygon(&uav, -1, -1); draw_polygon(&uav, 1, ca); move_polygon(&arrow, 0, -11); transform_polygon(&arrow, ca->width >> 1, ca->height >> 1, priv->direction - priv->heading); draw_polygon(&arrow, 3, ca); move_polygon(&arrow, -1, -1); draw_polygon(&arrow, 1, ca); switch (get_units(w->cfg)) { case UNITS_METRIC: default: sprintf(buf, "%dkm/h", (int) ((priv->speed * 3600) / 1000)); break; case UNITS_IMPERIAL: sprintf(buf, "%dmph", (int) ((priv->speed * 3600) * M2MILE)); break; case UNITS_CUSTOM_1: sprintf(buf, "%dm/s", (int) (priv->speed)); break; case UNITS_CUSTOM_2: sprintf(buf, "%df/s", (int) (priv->speed * M2FEET)); break; case UNITS_CUSTOM_3: sprintf(buf, "%dkn", (int) ((priv->speed * 3600 * 1.852) / 1000)); break; } draw_str(buf, 0, 0, ca, 0); } const struct widget_ops wind_widget_ops = { .name = "Wind information", .mavname = "WINDINF", .id = WIDGET_WIND_ID, .init = NULL, .open = open, .render = render, .close = NULL, };
static void cmd_sd(void) { real sd, variance; int units; unsigned long qmask, m; int quantity; qmask = get_qlist(BIT(Q_DECLINATION)); if (!qmask) return; /* no quantities found - error already reported */ if (qmask == BIT(Q_DEFAULT)) { default_grade(pcs); return; } sd = read_numeric(fFalse, NULL); if (sd <= (real)0.0) { compile_error_skip(-/*Standard deviation must be positive*/48); return; } units = get_units(qmask, fFalse); if (units == UNITS_NULL) return; sd *= factor_tab[units]; variance = sqrd(sd); for (quantity = 0, m = BIT(quantity); m <= qmask; quantity++, m <<= 1) if (qmask & m) pcs->Var[quantity] = variance; }
double get_depth_units(unsigned int mm, int *frac, const char **units) { int decimals; double d; const char *unit; struct units *units_p = get_units(); switch (units_p->length) { case METERS: d = mm / 1000.0; unit = _("m"); decimals = d < 20; break; case FEET: d = mm_to_feet(mm); unit = _("ft"); decimals = 0; break; } if (frac) *frac = decimals; if (units) *units = unit; return d; }
static void cmd_units(void) { int units, quantity; unsigned long qmask; unsigned long m; /* mask with bit x set to indicate quantity x specified */ real factor; qmask = get_qlist(0); if (!qmask) return; if (qmask == BIT(Q_DEFAULT)) { default_units(pcs); return; } factor = read_numeric(fTrue, NULL); if (factor == 0.0) { compile_error_skip(-/**UNITS factor must be non-zero*/200); return; } if (factor == HUGE_REAL) factor = (real)1.0; units = get_units(qmask, fTrue); if (units == UNITS_NULL) return; if (TSTBIT(qmask, Q_GRADIENT)) pcs->f_clino_percent = (units == UNITS_PERCENT); if (TSTBIT(qmask, Q_BACKGRADIENT)) pcs->f_backclino_percent = (units == UNITS_PERCENT); factor *= factor_tab[units]; for (quantity = 0, m = BIT(quantity); m <= qmask; quantity++, m <<= 1) if (qmask & m) pcs->units[quantity] = factor; }
void PlannerSettingsWidget::settingsChanged() { QString vs; // don't recurse into setting the value from the ui when setting the ui from the value ui.bottomSAC->blockSignals(true); ui.decoStopSAC->blockSignals(true); if (get_units()->length == units::FEET) { vs.append(tr("ft/min")); ui.lastStop->setText(tr("Last stop at 20ft")); ui.asc50to6->setText(tr("50% avg. depth to 20ft")); ui.asc6toSurf->setText(tr("20ft to surface")); } else { vs.append(tr("m/min")); ui.lastStop->setText(tr("Last stop at 6m")); ui.asc50to6->setText(tr("50% avg. depth to 6m")); ui.asc6toSurf->setText(tr("6m to surface")); } if(get_units()->volume == units::CUFT) { ui.bottomSAC->setSuffix(tr("cuft/min")); ui.decoStopSAC->setSuffix(tr("cuft/min")); ui.bottomSAC->setDecimals(2); ui.bottomSAC->setSingleStep(0.1); ui.decoStopSAC->setDecimals(2); ui.decoStopSAC->setSingleStep(0.1); ui.bottomSAC->setValue(ml_to_cuft(prefs.bottomsac)); ui.decoStopSAC->setValue(ml_to_cuft(prefs.decosac)); } else { ui.bottomSAC->setSuffix(tr("ℓ/min")); ui.decoStopSAC->setSuffix(tr("ℓ/min")); ui.bottomSAC->setDecimals(0); ui.bottomSAC->setSingleStep(1); ui.decoStopSAC->setDecimals(0); ui.decoStopSAC->setSingleStep(1); ui.bottomSAC->setValue((double) prefs.bottomsac / 1000.0); ui.decoStopSAC->setValue((double) prefs.decosac / 1000.0); } ui.bottomSAC->blockSignals(false); ui.decoStopSAC->blockSignals(false); updateUnitsUI(); ui.ascRate75->setSuffix(vs); ui.ascRate50->setSuffix(vs); ui.ascRateStops->setSuffix(vs); ui.ascRateLast6m->setSuffix(vs); ui.descRate->setSuffix(vs); }
QString DiveItem::displaySac() const { QString str; if (get_units()->volume == units::LITER) str = QString::number(dive->sac / 1000.0, 'f', 1).append(tr(" l/min")); else str = QString::number(ml_to_cuft(dive->sac), 'f', 2).append(tr(" cuft/min")); return str; }
QString get_weight_string(weight_t weight, bool showunit) { QString str = weight_string (weight.grams); if (get_units()->weight == units::KG) { str = QString ("%1%2").arg(str).arg(showunit ? translate("gettextFromC","kg") : ""); } else { str = QString ("%1%2").arg(str).arg(showunit ? translate("gettextFromC","lbs") : ""); } return (str); }
QString DiveItem::displayTemperature() const { QString str; if (!dive->watertemp.mkelvin) return str; if (get_units()->temperature == units::CELSIUS) str = QString::number(mkelvin_to_C(dive->watertemp.mkelvin), 'f', 1); else str = QString::number(mkelvin_to_F(dive->watertemp.mkelvin), 'f', 1); return str; }
static void render(struct widget *w) { struct home_data *priv = w->priv; struct canvas *ca = &w->ca; char buf[50]; float d, a; struct point arrow_points[7] = { {-3, 0}, {-3, -6}, {3, -6}, {3, 0}, {6, 0}, {0, 6}, {-6, 0} }; struct polygon arrow = { .len = 7, .points = arrow_points, }; if (priv->lock != HOME_LOCKED) { sprintf(buf, "No Home"); draw_str(buf, 0, 0, ca, 2); } else { switch (get_units(w->cfg)) { case UNITS_METRIC: default: sprintf(buf, "Alt %dm\nDis %dm\n%d", priv->altitude, (unsigned int) priv->distance, priv->direction); break; case UNITS_IMPERIAL: a = (float) priv->altitude * M2FEET; d = (float) priv->distance * M2FEET; sprintf(buf, "Alt %df\nDis %df\n%d", (unsigned int) a, (unsigned int) d, priv->direction); break; } draw_str(buf, 0, 0, ca, 1); transform_polygon(&arrow, 50, 34, priv->direction + 180); draw_polygon(&arrow, 3, ca); move_polygon(&arrow, -1, -1); draw_polygon(&arrow, 1, ca); } } const struct widget_ops home_info_widget_ops = { .name = "Home info", .mavname = "HOMEINF", .id = WIDGET_HOME_INFO_ID, .init = NULL, .open = open, .render = render, .close = NULL, };
void DivePlannerWidget::settingsChanged() { // Adopt units if (get_units()->length == units::FEET) { ui.atmHeight->setSuffix("ft"); } else { ui.atmHeight->setSuffix(("m")); } ui.atmHeight->blockSignals(true); ui.atmHeight->setValue((int) get_depth_units((int) (log(1013.0 / plannerModel->getSurfacePressure()) * 7800000), NULL,NULL)); ui.atmHeight->blockSignals(false); }
/** Render the number of credits */ void credits_render (void) { #ifdef FREE_ONLY sprintf ("FREE ONLY"); #else if (price_config.free_play) sprintf ("FREE PLAY"); else { if (get_units () != 0) { U8 units = get_units (); U8 units_per_credit = price_config.units_per_credit; /* There are fractional credits. Reduce to the * lowest common denominator before printing. */ reduce_unit_fraction (&units, &units_per_credit); if (get_credits () == 0) sprintf ("%d/%d CREDIT", units, units_per_credit); else sprintf ("%d %d/%d CREDITS", get_credits (), units, units_per_credit); } else { if (get_credits () == 1) sprintf ("%d CREDIT", get_credits ()); else sprintf ("%d CREDITS", get_credits ()); } } #endif if (diag_get_error_count ()) { sprintf ("%E."); } }
QString DiveItem::displayWeight() const { QString str; if (get_units()->weight == units::KG) { int gr = weight() % 1000; int kg = weight() / 1000; str = QString("%1.%2").arg(kg).arg((unsigned)(gr) / 100); } else { str = QString("%1").arg((unsigned)(grams_to_lbs(weight()))); } return str; }
static void render(struct widget *w) { struct canvas *ca = &w->ca; char buf[10]; mavlink_scaled_pressure_t *sp = mavdata_get(MAVLINK_MSG_ID_SCALED_PRESSURE); float temperature = sp->temperature / 100.0; char unit_char = 'C'; if (get_units(w->cfg) == UNITS_IMPERIAL) { temperature = temperature * 1.8 + 32; unit_char = 'F'; } sprintf(buf, "%.2f%c", (double) temperature, unit_char); draw_jstr(buf, X_SIZE, Y_SIZE/2, JUST_RIGHT | JUST_VCENTER, ca, 2); }
double get_temp_units(unsigned int mk, const char **units) { double deg; const char *unit; struct units *units_p = get_units(); if (units_p->temperature == FAHRENHEIT) { deg = mkelvin_to_F(mk); unit = UTF8_DEGREE "F"; } else { deg = mkelvin_to_C(mk); unit = UTF8_DEGREE "C"; } if (units) *units = unit; return deg; }
QString weight_string(int weight_in_grams) { QString str; if (get_units()->weight == units::KG) { int gr = weight_in_grams % 1000; int kg = weight_in_grams / 1000; if (kg >= 20.0) { str = QString("0"); } else { str = QString("%1.%2").arg(kg).arg((unsigned)(gr) / 100); } } else { double lbs = grams_to_lbs(weight_in_grams); str = QString("%1").arg(lbs, 0, 'f', lbs >= 40.0 ? 0 : 1); } return (str); }
static void render(struct widget *w) { struct widget_priv *priv = w->priv; struct canvas *ca = &w->ca; char buf[10], text[5]; int speed_i; switch (get_units(w->cfg)) { case UNITS_METRIC: default: speed_i = (int) ((priv->speed * 3600) / 1000); strcpy(text, "km/h"); break; case UNITS_IMPERIAL: speed_i = (int) ((priv->speed * 3600) * M2MILE); strcpy(text, "mph"); break; case UNITS_CUSTOM_1: speed_i = (int) (priv->speed); strcpy(text, "m/s"); break; case UNITS_CUSTOM_2: speed_i = (int) (priv->speed * M2FEET); strcpy(text, "f/s"); break; case UNITS_CUSTOM_3: speed_i = (int) ((priv->speed * 3600 * 1.852) / 1000); strcpy(text, "kn"); break; } switch (w->cfg->props.mode) { case 0: default: render_gauge(w, speed_i); break; case 1: snprintf(buf, 10, "%d%s", speed_i, text); draw_jstr(buf, X_SIZE_TEXT - 1, 10, JUST_RIGHT | JUST_VCENTER, ca, 1); break; } }
void TestUnitConversion::testUnitConversions() { QCOMPARE(IS_FP_SAME(grams_to_lbs(1000), 2.204586), true); QCOMPARE(lbs_to_grams(1), 454); QCOMPARE(IS_FP_SAME(ml_to_cuft(1000), 0.0353147), true); QCOMPARE(IS_FP_SAME(cuft_to_l(1), 28.316847), true); QCOMPARE(IS_FP_SAME(mm_to_feet(1000), 3.280840), true); QCOMPARE(feet_to_mm(1), (long unsigned int) 305); QCOMPARE(to_feet((depth_t){ 1000 }), 3); QCOMPARE(IS_FP_SAME(mkelvin_to_C(647000), 373.85), true); QCOMPARE(IS_FP_SAME(mkelvin_to_F(647000), 704.93), true); QCOMPARE(F_to_mkelvin(704.93), (unsigned long)647000); QCOMPARE(C_to_mkelvin(373.85), (unsigned long)647000); QCOMPARE(IS_FP_SAME(psi_to_bar(14.6959488), 1.01325), true); QCOMPARE(psi_to_mbar(14.6959488), (long)1013); QCOMPARE(to_PSI((pressure_t){ 1013 }), (int)15); QCOMPARE(IS_FP_SAME(bar_to_atm(1.013), 1.0), true); QCOMPARE(IS_FP_SAME(mbar_to_atm(1013), 1.0), true); QCOMPARE(mbar_to_PSI(1013), (int)15); get_units(); }
void PlannerSettingsWidget::settingsChanged() { QString vs; if (get_units()->length == units::FEET) { vs.append(tr("ft/min")); ui.lastStop->setText(tr("Last stop at 20ft")); ui.asc50to6->setText(tr("50% avg. depth to 20ft")); ui.asc6toSurf->setText(tr("20ft to surface")); } else { vs.append(tr("m/min")); ui.lastStop->setText(tr("Last stop at 6m")); ui.asc50to6->setText(tr("50% avg. depth to 6m")); ui.asc6toSurf->setText(tr("6m to surface")); } updateUnitsUI(); ui.ascRate75->setSuffix(vs); ui.ascRate50->setSuffix(vs); ui.ascRateStops->setSuffix(vs); ui.ascRateLast6m->setSuffix(vs); ui.descRate->setSuffix(vs); }
double get_weight_units(unsigned int grams, int *frac, const char **units) { int decimals; double value; const char* unit; struct units *units_p = get_units(); if (units_p->weight == LBS) { value = grams_to_lbs(grams); unit = _("lbs"); decimals = 0; } else { value = grams / 1000.0; unit = _("kg"); decimals = 1; } if (frac) *frac = decimals; if (units) *units = unit; return value; }
double get_vertical_speed_units(unsigned int mms, int *frac, const char **units) { double d; const char *unit; const struct units *units_p = get_units(); const double time_factor = units_p->vertical_speed_time == MINUTES ? 60.0 : 1.0; switch (units_p->length) { case METERS: d = mms / 1000.0 * time_factor; unit = translate("gettextFromC",(units_p->vertical_speed_time == MINUTES) ? "m/min" : "m/s"); break; case FEET: d = mm_to_feet(mms) * time_factor; unit = translate("gettextFromC",(units_p->vertical_speed_time == MINUTES) ? "ft/min" : "ft/s"); break; } if (frac) *frac = d < 10; if (units) *units = unit; return d; }
int get_pressure_units(unsigned int mb, const char **units) { int pressure; const char* unit; struct units *units_p = get_units(); switch (units_p->pressure) { case PASCAL: pressure = mb * 100; unit = _("pascal"); break; case BAR: pressure = (mb + 500) / 1000; unit = _("bar"); break; case PSI: pressure = mbar_to_PSI(mb); unit = _("psi"); break; } if (units) *units = unit; return pressure; }
int main(int argc, char *argv[]) { char cdf_name[250]; /***************** declared local pointers to store returned attribute value pointers ************/ char *char_attribute_valuePtr; int *int_attribute_valuePtr; float *float_attribute_valuePtr; if (argc != 2) { printf("ERROR:this example program requires 1 argument - full path and file name of data file\n"); exit( EXIT_FAILURE); } strcpy(cdf_name, argv[1]); open_cdf(cdf_name, 0); printf("Open %s complete...\n", cdf_name); /*** get the README GLOBAL ATTRIBUTE value ***/ if (attribute_exists("README") ) char_attribute_valuePtr = gattribute_get("README"); if (attribute_exists("README") ) { printf("\n\nREADME attribute = %s\n", char_attribute_valuePtr); } /*** get the grid_system_count global attribute value ***/ if (attribute_exists("grid_system_count") ) int_attribute_valuePtr = gattribute_get("grid_system_count"); if (attribute_exists("grid_system_count") ) { printf("\ngrid_system_count attribute = %d\n\n", *int_attribute_valuePtr); } /*** test for the existence of gattributes ***/ printf("attribute_exists( \"model_name\" ) = %d\n", attribute_exists("model_name") ); printf("attribute_exists( \"model_type\" ) = %d\n", attribute_exists("model_type") ); printf("attribute_exists( \"elapsed_time_in_seconds\") = %d\n", attribute_exists("elapsed_time_in_seconds") ); printf("attribute_exists( \"horse_power\") = %d\n", attribute_exists("horse_power") ); printf("attribute_exists( \"units\") = %d\n", attribute_exists("units") ); /*** get the elapsed_time_in_seconds global attribute value ***/ if (attribute_exists("elapsed_time_in_seconds") ) float_attribute_valuePtr = gattribute_get("elapsed_time_in_seconds"); if (attribute_exists("elapsed_time_in_seconds") ) { printf("\nelapsed_time_in_seconds attribute = %f\n", *float_attribute_valuePtr); } /*** get the description variable ATTRIBUTE value for x ***/ if (var_exists("x") && attribute_exists("description") ) char_attribute_valuePtr = vattribute_get("x", "description"); if (var_exists("x") && attribute_exists("description") ) { printf("\ndescription attribute = %s\n", char_attribute_valuePtr); } /*** get the is_vector_component variable attribute value for bx ***/ if (var_exists("bx") && attribute_exists("is_vector_component") ) int_attribute_valuePtr = vattribute_get("bx", "is_vector_component"); if (var_exists("bx") && attribute_exists("is_vector_component") ) { printf("\nis_vector_component attribute = %d\n", *int_attribute_valuePtr); } /*** get the valid_min variable attribute value for rho***/ if (var_exists("rho") && attribute_exists("valid_min") ) float_attribute_valuePtr = vattribute_get("rho", "valid_min"); if (var_exists("rho") && attribute_exists("valid_min") ) { printf("\nvalid_min attribute = %f\n", *float_attribute_valuePtr); } /*** get the units variable attribute value for rho***/ if (var_exists("rho") && attribute_exists("units") ) char_attribute_valuePtr = vattribute_get("rho", "units"); if (var_exists("rho") && attribute_exists("units") ) { printf("\nunits attribute = %s\n", char_attribute_valuePtr); } printf("DEBUG\tlegacy stuff\n\n\n\n"); /********** legacy routines... before generic *attribute_get routines were available ***/ /** char * get_units( "variable_name" ); **/ if (var_exists("x") && attribute_exists("units") ) printf( "\nAN example of using the get_units() routine: units for X = %s\n", get_units("x") ); /*** float gattribute_float_get( "global_attribute_name" ); **/ if (attribute_exists("elapsed_time_in_seconds") ) printf( "\nAN example of using the gattribute_float_get() routine: elapsed_time_in_seconds %f\n", gattribute_float_get("elapsed_time_in_seconds") ); /*** char * gattribute_char_get( "global_attribute_name" ); **/ if (attribute_exists("model_name") ) printf( "\nAN example of using the gattribute_char_get() routine, model_name = %s\n", gattribute_char_get("model_name") ); return 1; }
QVariant ProfilePrintModel::data(const QModelIndex &index, int role) const { const int row = index.row(); const int col = index.column(); switch (role) { case Qt::DisplayRole: { struct DiveItem di; di.dive = dive; char buf[80]; const QString unknown = tr("unknown"); // dive# + date, depth, location, duration if (row == 0) { if (col == 0) return tr("Dive #%1 - %2").arg(dive->number).arg(di.displayDate()); if (col == 5) { QString unit = (get_units()->length == units::METERS) ? "m" : "ft"; return tr("Max depth: %1 %2").arg(di.displayDepth()).arg(unit); } } if (row == 1) { if (col == 0) return truncateString(dive->location, 32); if (col == 5) return QString(tr("Duration: %1 min")).arg(di.displayDuration()); } // cylinder headings if (row == 2) { if (col == 0) return tr("Cylinder"); if (col == 1) return tr("Gasmix"); if (col == 2) return tr("Gas Used"); } // cylinder data if (row > 2 && row < 10 && row - 3 < MAX_CYLINDERS) { cylinder_t *cyl = &dive->cylinder[row - 3]; if (cyl->type.description) { // how do we check if a cylinder is added? if (col == 0) { if (cyl->type.description[0] != '\0') return QString(cyl->type.description); return unknown; } if (col == 1) { get_gas_string(cyl->gasmix.o2.permille, cyl->gasmix.he.permille, buf, sizeof(buf)); return QString(buf); } if (col == 2) { return get_cylinder_used_gas_string(cyl, true); } } } // dive notes if (row == 10 && col == 0) return truncateString(dive->notes, 640); // sac, cns, otu - headings if (col == 3) { if (row == 2) return tr("SAC"); if (row == 4) return tr("Max. CNS"); if (row == 6) return tr("OTU"); } // sac, cns, otu - data if (col == 4) { if (row == 2) return di.displaySac(); if (row == 4) return QString::number(dive->maxcns); if (row == 6) return QString::number(dive->otu); } // weights heading if (row == 2 && col == 5) return tr("Weights"); // total weight if (row == 9) { weight_t tw = { total_weight(dive) }; if (tw.grams) { if (col == 5) return tr("Total weight"); if (col == 6) return get_weight_string(tw, true); } } // weight data if (row > 2 && row < 10 && row - 3 < MAX_WEIGHTSYSTEMS) { weightsystem_t *ws = &dive->weightsystem[row - 3]; if (ws->weight.grams) { if (col == 5) { if (ws->description && ws->description[0] != '\0') return QString(ws->description); return unknown; } if (col == 6) { return get_weight_string(ws->weight, true); } } } return QString(); } case Qt::FontRole: { QFont font; const int baseSize = 9; // dive # if (row == 0 && col == 0) { font.setBold(true); font.setPixelSize(baseSize + 1); return QVariant::fromValue(font); } // dive location if (row == 1 && col == 0) { font.setPixelSize(baseSize); font.setBold(true); return QVariant::fromValue(font); } // depth/duration if ((row == 0 || row == 1) && col == 5) { font.setPixelSize(baseSize); return QVariant::fromValue(font); } // notes if (row == 9 && col == 0) { font.setPixelSize(baseSize + 1); return QVariant::fromValue(font); } font.setPixelSize(baseSize); return QVariant::fromValue(font); } case Qt::TextAlignmentRole: { unsigned int align = Qt::AlignCenter; // dive #, location, notes if ((row < 2 || row == 10) && col == 0) align = Qt::AlignLeft | Qt::AlignVCenter; // depth, duration if (row < 2 && col == 5) align = Qt::AlignRight | Qt::AlignVCenter; return QVariant::fromValue(align); } } // switch (role) return QVariant(); }
static void render(struct widget *w) { struct widget_priv *priv = w->priv; struct canvas *ca = &w->ca; char buf[10]; unsigned long d = (unsigned long) priv->home->distance; unsigned int r = (w->ca.width/2)-2; int x, y; int min_increment; long i, scale; struct point ils_points[5] = { {-4, -6}, {-4, 6}, {0, 10}, {4, 6}, {4, -6} }; struct polygon ils = { .len = 5, .points = ils_points, }; struct point uav_points[4] = { {0, 0}, {6, 8}, {0, -8}, {-6, 8} }; struct polygon uav = { .len = 4, .points = uav_points, }; struct polygon *p; x = (w->ca.width/2)-1; y = (w->ca.height/2)-1; draw_vline(x, 0, r*2, 2, ca); draw_hline(0, r*2, y, 2, ca); //draw_circle(x, y, r+1, 3, ca); draw_circle(x, y, r , 2, ca); /* auto scale */ switch (get_units(w->cfg)) { default: case UNITS_METRIC: min_increment = 500; scale = ((d / min_increment) + 1) * min_increment; sprintf(buf, "%um", (unsigned int) scale); break; case UNITS_IMPERIAL: d *= M2FEET; min_increment = 1000; scale = ((d / min_increment) + 1) * min_increment; if (d > 5000) { d = (d * 1000) / MILE2FEET; scale /= 1000; sprintf(buf, "%umi", (unsigned int) scale); } else { sprintf(buf, "%uf", (unsigned int) scale); } break; } draw_str(buf, 0, 0, ca, 0); i = (long) d * r; i /= scale; switch (w->cfg->props.mode >> 1) { case 0: default: /* radar fixed at uav heading, home moves */ x += sin(DEG2RAD(priv->home->direction)) * i; y -= cos(DEG2RAD(priv->home->direction)) * i; transform_polygon(&ils, x, y, priv->stats->launch_heading - priv->heading - 180); p = &ils; break; case 1: /* radar always facing north, uav moves */ x += sin(DEG2RAD(priv->home->uav_bearing)) * i; y -= cos(DEG2RAD(priv->home->uav_bearing)) * i; transform_polygon(&uav, x, y, priv->heading); p = &uav; break; case 2: /* radar always facing launch direction, uav moves */ x += sin(DEG2RAD(priv->home->uav_bearing - priv->stats->launch_heading)) * i; y -= cos(DEG2RAD(priv->home->uav_bearing - priv->stats->launch_heading)) * i; transform_polygon(&uav, x, y, priv->heading - priv->stats->launch_heading); p = &uav; break; case 3: /* testing waypoints */ /* radar always facing north, uav moves with waypoints */ if (priv->wp_seq > 0) { long i_wp = (long) priv->wp_distance * r; i_wp /= scale; int x_wp = x, y_wp = y; x_wp += sin(DEG2RAD(priv->wp_target_bearing - priv->heading)) * i_wp; y_wp -= cos(DEG2RAD(priv->wp_target_bearing - priv->heading)) * i_wp; sprintf(buf, "%d", priv->wp_seq); draw_str(buf, x_wp, y_wp, ca, 0); } x += sin(DEG2RAD(priv->home->uav_bearing)) * i; y -= cos(DEG2RAD(priv->home->uav_bearing)) * i; transform_polygon(&uav, x, y, priv->heading); p = &uav; break; } draw_polygon(p, 3, ca); move_polygon(p, -1, -1); draw_polygon(p, 1, ca); } const struct widget_ops radar_widget_ops = { .name = "Radar", .mavname = "RADAR", .id = WIDGET_RADAR_ID, .init = NULL, .open = open, .render = render, .close = NULL, };