Example #1
0
void t(){

  gStyle->SetOptStat(0);
  gStyle->SetPadLeftMargin(0.13);
  gStyle->SetPadBottomMargin(0.13);

  TFile *f_bef = TFile::Open("hists/sig_nofilt_noeff.root");
  TH2F *tb = (TH2F*) f_bef->Get("inv_p_t_pbar_pi0_lab_the_pi0");
  tb->SetTitle("#theta_{#pi^{0}} vs t;t[(GeV)^{2}];#theta_{#pi^{0}}[#circ]");
  set_style(tb->GetXaxis());
  set_style(tb->GetYaxis());


  TFile* f_aft = TFile::Open("hists/sig_noeff.root");
  TH1F *ta = (TH1F*) f_aft->Get("inv_p_t_pbar_pi0");
  //  tb->SetTitle(Form("#theta_{J/#psi} in #bar{p}p#rightarrow%s", rxn.c_str()));
  ta->SetTitle("t;t[(GeV)^{2}]");
  ta->GetXaxis()->SetRangeUser(-0.8,0.8);
  set_style(ta->GetXaxis());
  set_style(ta->GetYaxis());


  TCanvas *tc0 = new TCanvas("tc0","tc0",1100,500);
  tc0->Divide(2,1);
  tc0->cd(1);
  tb->Draw("colz");

  TLatex *tt = new TLatex();
  tt->SetTextSize(0.06);
  tt->SetNDC();
  tt->DrawLatex(0.5,0.5,"s=12.25 GeV^{2}");

  tc0->cd(2);
  ta->Draw();
  tt->DrawLatex(0.19,0.7,"s=12.25 GeV^{2}");
  tt->DrawLatex(0.19,0.6,"After MC rejection");

  tc0->Print("figs/t_vs_the_pi0.pdf");

  TCanvas *tc1 = new TCanvas("tc1","tc1",1400,1000);
  tc1->cd();
  ta->Draw();
  tt->DrawLatex(0.19,0.7,"s=12.25 GeV^{2}");
  tt->DrawLatex(0.19,0.6,"Forward Hemesphere in CM");
  //tt->DrawLatex(0.19,0.5,"After MC rejection");


}
Example #2
0
static void handle_tap(AccelAxisType axis, int32_t direction) {
    persist_write_bool(STYLE_KEY, !persist_read_bool(STYLE_KEY));
    set_style();
    force_update();
    vibes_long_pulse();
    accel_tap_service_unsubscribe();
}
Example #3
0
void Label::set_text_color(const Colorf color)
{
	CSSValueColor value;
	value.color = color;
	value.type = value.type_color;
	set_style(value, true);
}
Example #4
0
void DemoCMotion::on_key_up(const clan::InputEvent& key, clan::Canvas canvas)
{
	if( key.id == clan::keycode_escape )
		quit = true;

	else if( key.id == clan::keycode_z)
	{
		current_style = (current_style+1)%2;
		set_style(canvas);
	}

	else if( key.id == clan::keycode_x)
	{
		random_ini_rotation = !random_ini_rotation;
		if( random_ini_rotation )
			effect->set_rotation_distortion(L_DEGREE_TO_RADIAN(200));

		else
			effect->set_rotation_distortion(0);
	}

	else if( key.id == clan::keycode_f1)
		show_menu = !show_menu;

	else if( key.id == clan::keycode_space)
		clan::System::sleep(rand()%200+50);
}
Example #5
0
void SessionRep::connect(Display* d) {
    set_style(d);
    Dispatcher::instance().link(
	d->fd(), Dispatcher::ReadMask, new SessionIOHandler(this, d)
    );
    displays_->append(d);
}
Example #6
0
static void handle_init(void) {
    window = window_create();
    window_stack_push(window, true /* Animated */);

    // child init
    simplebig_init(window);
    status_init(window);
    termo_init(window);

    // Register callbacks
    app_message_register_inbox_received(inbox_received_callback);
    app_message_register_inbox_dropped(inbox_dropped_callback);
    app_message_register_outbox_failed(outbox_failed_callback);
    app_message_register_outbox_sent(outbox_sent_callback);

    // Open AppMessage
    AppMessageResult result = app_message_open(APP_MESSAGE_INBOX_SIZE_MINIMUM, APP_MESSAGE_OUTBOX_SIZE_MINIMUM);
    if (result != APP_MSG_OK) {
        APP_LOG(APP_LOG_LEVEL_ERROR, "Can't open inbox");
    }

    // handlers
    tick_timer_service_subscribe(MINUTE_UNIT, handle_minute_tick);
    UnobstructedAreaHandlers ua_handler = {
        .change = handle_unobstructed_change
    };
    unobstructed_area_service_subscribe(ua_handler, NULL);

    // style
    set_style();

    // draw first frame
    force_update();
}
Example #7
0
// Display the atlas statusbar
int main(int argc, char **argv) {
    
    // Enable multi threading
    XInitThreads();
    
    // Initialize gtk toolkit
    gtk_init(&argc, &argv);
    
    // Setup widgets
    set_style();
    
    // Display widgets
    display_frame();
    display_tags(1);
    display_date(attrList);
    display_battery();
    display_wifi();
    display_volume();
    display_brightness();
    
    signal(SIGUSR1, widget_updater);
    
    // Run the gtk loop
    gtk_main();
    
    return 0;    
}
variable flux_set_style(opts o,interpreter *i)
{
	variable v=init_variable();
	int buffer=0;
	int style=0;
	if (i->cast_int(&buffer,o,0) && i->cast_int(&style,o,1))
		set_style(buffer,style);
	return v;
}
Example #9
0
void YahooParser::tag_end(const QString &tag)
{
    style saveStyle =curStyle;
    while (!tags.empty()) {
        saveStyle = tags.top();
        tags.pop();
        if (saveStyle.tag == tag)
            break;
    }
    set_style(saveStyle);
}
Example #10
0
Halftone_TX::Halftone_TX(Patch* p) :
   GLSLShader_Layer_Base(p,new StripOpCB()),
   _use_alpha_transitions(false)
{
   for (int i=0; i<MAX_LAYERS; i++)
      _layers.push_back(new halftone_layer_t());

   // setup a default style here
   _layers[0]->_mode = 2; //procedural dots;
   set_style(0);
}
Example #11
0
void
edit_typeset_rep::set_data (new_data data) {
  set_style (data->style);
  set_init  (data->init);
  set_fin   (data->fin);
  set_att   (data->att);
  notify_page_change ();
  add_init (data->init);
  notify_change (THE_DECORATIONS);
  typeset_invalidate_env ();
}
Example #12
0
// MESSAGING
static void inbox_received_callback(DictionaryIterator *iterator, void *context) {

    // Look for item
    Tuple *t = dict_find(iterator, MESSAGE_KEY_INVERSE);
 
    // For all items
    if (t) {
        persist_write_bool(STYLE_KEY, t->value->int32 == 1);
        set_style();
        force_update();
        vibes_long_pulse();
    }

    termo_inbox_received(iterator, context);
}
Example #13
0
void draw_component(int origin_x, int origin_y, component *comp) {
	int x = comp->x+origin_x;
	int y = comp->y+origin_y;
	if (comp->hidden == 0) {
		set_style(comp->style);
		set_color(comp->color);
		set_bgcolor(comp->bgcolor);
		draw(x, y, comp->resource);
	}
	if (comp->next != NULL) {
		draw_component(origin_x, origin_y, comp->next);
	}
	if (comp->child != NULL) {
		draw_component(x, y, comp->child);
	}
}
NBFMOptionsView::NBFMOptionsView(
	const Rect parent_rect, const Style* const style
) : View { parent_rect }
{
	set_style(style);

	add_children({ {
		&label_config,
		&options_config,
	} });

	options_config.set_selected_index(receiver_model.nbfm_configuration());
	options_config.on_change = [this](size_t n, OptionsField::value_t) {
		receiver_model.set_nbfm_configuration(n);
	};
}
Example #15
0
void
edit_main_rep::print (url name, bool conform, int first, int last) {
  if (inside ("screens")) {
    tree style= copy (get_style ());
    tree init = copy (get_init ());
    tree t    = copy (subtree (et, rp));
    call ("dynamic-make-slides");
    apply_changes ();
    print_bis (name, conform, first, last);
    set_style (style);
    set_init (init);
    assign (rp, t);
    apply_changes ();
  }
  else print_bis (name, conform, first, last);
}
Example #16
0
FrequencyOptionsView::FrequencyOptionsView(
	const Rect parent_rect,
	const Style* const style
) : View { parent_rect }
{
	set_style(style);

	options_step.on_change = [this](size_t n, OptionsField::value_t v) {
		(void)n;
		this->on_step_changed(v);
	};

	add_children({ {
		&text_step,
		&options_step,
	} });
}
Example #17
0
/**
 * @brief Creates a new dialog box.
 * @param game the game this dialog box belongs to
 */
DialogBox::DialogBox(Game &game):
  game(game),
  issuer_script(NULL),
  dialog_surface(320, 240),
  box_img("hud/dialog_box.png"),
  icons_img("hud/dialog_icons.png"),
  end_lines_sprite("hud/dialog_box_message_end"),
  box_src_position(0, 0, 220, 60),
  box_dst_position(0, 0, 220, 60),
  question_src_position(96, 60, 8, 8) {

  dialog_surface.set_transparency_color(Color::get_black());
  set_style(STYLE_WITH_FRAME);

  for (int i = 0; i < nb_visible_lines; i++) {
    line_surfaces[i] = new TextSurface(0, 0, TextSurface::ALIGN_LEFT,
        TextSurface::ALIGN_TOP);
  }
}
Example #18
0
static void
add_cell (Sheet *sheet, const psiconv_sheet_cell psi_cell,
	  const psiconv_formula_list psi_formulas, const GnmStyle * default_style)
{
	GnmCell *cell;
	GnmValue *val;
	GnmExprTop const *expr = NULL;

	cell = sheet_cell_fetch (sheet, psi_cell->column, psi_cell->row);
	if (!cell)
		return;

	val = value_new_from_psi_cell (psi_cell);

	if (psi_cell->calculated)
		expr = expr_new_from_formula (psi_cell, psi_formulas);

	if (expr != NULL) {
		/* TODO : is there a notion of parse format ?
		 * How does it store a user entered date ?
		 */
		if (val != NULL)
			gnm_cell_set_expr_and_value (cell, expr, val, TRUE);
		else
			gnm_cell_set_expr (cell, expr);
	} else if (val != NULL) {
		/* TODO : is there a notion of parse format ?
		 * How does it store a user entered date ?
		 */
		gnm_cell_set_value (cell, val);
	} else {
		/* TODO : send this warning to iocontext with details of
		 * which sheet and cell.
		 */
		g_warning ("Cell with no value or expression ?");
	}
	if (expr)
		gnm_expr_top_unref (expr);

	/* TODO: Perhaps this must be moved above set_format */
	set_style(sheet,psi_cell->row,psi_cell->column,psi_cell->layout,
	          default_style);
}
Example #19
0
File: init.c Project: kawatea/cedit
void init_editor(GtkWidget *box)
{
    //エディタ部分の外観の設定
    GtkWidget *notebook = gtk_notebook_new();
    scroll_window = gtk_scrolled_window_new(NULL, NULL);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
    buffer = gtk_source_buffer_new(NULL);
    view = gtk_source_view_new_with_buffer(buffer);
    set_file_name("");
    name_label = gtk_label_new("編集中のファイル");
    gtk_container_add(GTK_CONTAINER(scroll_window), view);
    gtk_notebook_append_page(GTK_NOTEBOOK(notebook), scroll_window, name_label);
    gtk_widget_set_has_tooltip(view, TRUE);
    gtk_widget_grab_focus(view);
    set_style();
    gtk_box_pack_start(GTK_BOX(box), notebook, TRUE, TRUE, 0);
    
    //エディタ部分の動作の初期設定
    gtk_source_buffer_set_highlight_matching_brackets(buffer, FALSE);
    gtk_widget_modify_font(view, pango_font_description_from_string(font_name));
    gtk_source_view_set_tab_width(GTK_SOURCE_VIEW(view), state & width_mask);
    if (state & wrap_mask) {
        gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(view), GTK_WRAP_CHAR);
    } else {
        gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(view), GTK_WRAP_NONE);
    }
    if (state & line_mask) {
        gtk_source_view_set_show_line_numbers(GTK_SOURCE_VIEW(view), TRUE);
    } else {
        gtk_source_view_set_show_line_numbers(GTK_SOURCE_VIEW(view), FALSE);
    }
    if (state & highlight_mask) {
        gtk_source_view_set_highlight_current_line(GTK_SOURCE_VIEW(view), TRUE);
    } else {
        gtk_source_view_set_highlight_current_line(GTK_SOURCE_VIEW(view), FALSE);
    }
    if (state & space_mask) {
        gtk_source_view_set_insert_spaces_instead_of_tabs(GTK_SOURCE_VIEW(view), TRUE);
    } else {
        gtk_source_view_set_insert_spaces_instead_of_tabs(GTK_SOURCE_VIEW(view), FALSE);
    }
}
Example #20
0
DemoCMotion::DemoCMotion(clan::DisplayWindow &window) : window(window), fontColor(255.0f, 255.0f, 255.0f), blendingMode(L_ADDITIVE_BLENDING)
{
	window.set_title("LinearParticle Example - CMotion ");
	sc.connect(window.sig_window_close(), clan::bind_member(this, &DemoCMotion::on_window_close));
	canvas = clan::Canvas(window);

	sc.connect(window.get_keyboard().sig_key_up(), [&](const clan::InputEvent &input){on_key_up(input, canvas); });

	// initialize LinearParticle
	L_ParticleSystem::init();

	// create surface to be used for particle and set the alignment
	surface = clan::Sprite(canvas,"Resources/sketch.png");
	surface.set_alignment(clan::origin_center);
	font = clan::Font("Arial", 16);

	motion_ctrl.set_speed_limit(0.65f);
	motion_ctrl.set_point_acceleration( 320, 240, 0.001f );

	particle = clan::make_unique<L_Particle>(&surface, 3000);
	particle->rotating4();
	particle->set_motion_controller(&motion_ctrl);


	L_Vector shooting_vector;
	shooting_vector.set2( 0.4, L_DEGREE_TO_RADIAN(-90) );
	effect = clan::make_unique<L_ShootingEffect>(460, 360, shooting_vector, 16, 6);
	effect->add(particle.get());
	effect->set_width_interval(20);
	effect->set_angle_interval(L_DEGREE_TO_RADIAN(40));
	effect->set_life_distortion(600);
	effect->set_size_distortion(0.4f);
	effect->set_speed_distortion(0.06f);
	effect->initialize();

	bg_color = clan::Colorf(0.0f,0.0f,0.0f);

	set_style(canvas);

	last_time = clan::System::get_time();

}
Example #21
0
ColorWheel::ColorWheel(clan::Canvas &canvas, clan::GUIManager &gui, clan::Rect gui_position) : clan::GUIComponent(&gui, clan::GUITopLevelDescription("ColorWheel", gui_position, false))
{
    clan::CSSValueBackgroundColor color;
    color.color = clan::Colorf::black;
    set_style(color, true);	// We want a black background

    saturation_outer = 1.0f;
    saturation_inner = 0.0f;
    value_outer = 1.0f;
    value_inner = 0.0f;
    is_hsl = false;

    slider_saturation_outer = create_slider(16, 16);
    slider_saturation_inner = create_slider(16, 48);
    slider_value_outer = create_slider(16, 80);
    slider_value_inner = create_slider(16, 112);

    slider_saturation_outer->set_position(slider_saturation_outer->get_max());
    slider_saturation_inner->set_position(0);
    slider_value_outer->set_position(slider_value_outer->get_max());
    slider_value_inner->set_position(0);

    radiobutton_HSV = new clan::RadioButton(this);
    radiobutton_HSV->set_geometry(clan::Rect(16, 0 , clan::Size(64, 16)));
    radiobutton_HSV->set_text("         ");		// ** I'm got lazy to set the text color to white, so I draw it elsewhere
    radiobutton_HSV->set_selected(true);
    radiobutton_HSV->set_group_name("Main Group");
    radiobutton_HSV->func_selected() = bind_member(this, &ColorWheel::on_selected, radiobutton_HSV);

    radiobutton_HSL = new clan::RadioButton(this);
    radiobutton_HSL->set_geometry(clan::Rect(100, 0, clan::Size(64, 16)));
    radiobutton_HSL->set_text("         ");
    radiobutton_HSL->set_group_name("Main Group");
    radiobutton_HSL->func_selected() = bind_member(this, &ColorWheel::on_selected, radiobutton_HSL);

    radiobutton_HSV->set_selected(true);

    func_render() = bind_member(this, &ColorWheel::on_render);

    font = clan::Font(canvas, "tahoma", 16);

}
Example #22
0
static void apply_styles(struct game_state *s) {	
	set_style(s, "foreground", "white");
	set_style(s, "background", "black");
	
	set_style_gt0(s, "margin", "1");
	set_style_gt0(s, "padding", "1");
	
	set_style_gt0(s, "border", "0");
	set_style_gt0(s, "border-radius", "0");	
	set_style(s, "border-color", get_style(s, "foreground"));
	
	set_style_gt0(s, "button-padding", "5");
	set_style_gt0(s, "button-border-radius", "1");
	
	set_style(s, "font", "normal");
	
	set_style(s, "image", NULL);
	set_style(s, "image-align", "top");
	set_style(s, "image-mask", NULL);
	set_style_gt0(s, "image-margin", "0");
}
FrequencyOptionsView::FrequencyOptionsView(
	const Rect parent_rect,
	const Style* const style
) : View { parent_rect }
{
	set_style(style);

	options_step.on_change = [this](size_t n, OptionsField::value_t v) {
		(void)n;
		this->on_step_changed(v);
	};

	field_ppm.on_change = [this](int32_t v) {
		this->on_reference_ppm_correction_changed(v);
	};

	add_children({ {
		&text_step,
		&options_step,
		&text_correction,
		&field_ppm,
		&text_ppm,
	} });
}
RadioGainOptionsView::RadioGainOptionsView(
	const Rect parent_rect,
	const Style* const style
) : View { parent_rect }
{
	set_style(style);

	add_children({ {
		&label_rf_amp,
		&field_rf_amp,
		//&label_agc,
		//&field_agc
	} });

	field_rf_amp.on_change = [this](int32_t v) {
		this->on_rf_amp_changed(v);
	};
	/*
	field_agc.set_value(receiver_model.agc());
	field_agc.on_change = [this](int32_t v) {
		this->on_agc_changed(v);
	};
	*/
}
Example #25
0
void ps_printer::flush_sbuf()
{
  enum {
    NONE,
    RELATIVE_H,
    RELATIVE_V,
    RELATIVE_HV,
    ABSOLUTE
    } motion = NONE;
  int space_flag = 0;
  if (sbuf_len == 0)
    return;
  if (output_style != sbuf_style) {
    set_style(sbuf_style);
    output_style = sbuf_style;
  }
  int extra_space = 0;
  if (output_hpos < 0 || output_vpos < 0)
    motion = ABSOLUTE;
  else {
    if (output_hpos != sbuf_start_hpos)
      motion = RELATIVE_H;
    if (output_vpos != sbuf_vpos) {
      if  (motion != NONE)
	motion = RELATIVE_HV;
      else
	motion = RELATIVE_V;
    }
  }
  if (sbuf_space_code >= 0) {
    int w = sbuf_style.f->get_width(space_glyph, sbuf_style.point_size);
    if (w + sbuf_kern != sbuf_space_width) {
      if (sbuf_space_code != output_space_code) {
	set_space_code(sbuf_space_code);
	output_space_code = sbuf_space_code;
      }
      space_flag = 1;
      extra_space = sbuf_space_width - w - sbuf_kern;
      if (sbuf_space_diff_count > sbuf_space_count/2)
	extra_space++;
      else if (sbuf_space_diff_count < -(sbuf_space_count/2))
	extra_space--;
    }
  }
  if (space_flag)
    out.put_fix_number(extra_space);
  if (sbuf_kern != 0)
    out.put_fix_number(sbuf_kern);
  out.put_string(sbuf, sbuf_len);
  char command_array[] = {'A', 'B', 'C', 'D',
			  'E', 'F', 'G', 'H',
			  'I', 'J', 'K', 'L',
			  'M', 'N', 'O', 'P',
			  'Q', 'R', 'S', 'T'};
  char sym[2];
  sym[0] = command_array[motion*4 + space_flag + 2*(sbuf_kern != 0)];
  sym[1] = '\0';
  switch (motion) {
  case NONE:
    break;
  case ABSOLUTE:
    out.put_fix_number(sbuf_start_hpos)
       .put_fix_number(sbuf_vpos);
    break;
  case RELATIVE_H:
    out.put_fix_number(sbuf_start_hpos - output_hpos);
    break;
  case RELATIVE_V:
    out.put_fix_number(sbuf_vpos - output_vpos);
    break;
  case RELATIVE_HV:
    out.put_fix_number(sbuf_start_hpos - output_hpos)
       .put_fix_number(sbuf_vpos - output_vpos);
    break;
  default:
    assert(0);
  }
  out.put_symbol(sym);
  output_hpos = sbuf_end_hpos;
  output_vpos = sbuf_vpos;
  sbuf_len = 0;
}
Example #26
0
double fourrier() {

  gStyle->SetOptStat(0);
  gStyle->SetPadLeftMargin(0.13);
  gStyle->SetPadBottomMargin(0.13);
  //gStyle->SetTitleOffset(0.0,"X");
  gStyle->SetTitleFontSize(0.08);
  gStyle->SetTitleFont(62);
  //gStyle->SetTitleAlign(33);
  //TGaxis::SetMaxDigits(3);

  double pars[] = { 6.35356e+00,
		    1.0,
		    4.13113e+00,
  		    -4.43669e+00,
		    0.1,
		    0.01,
		    0.1,
		    9.64513e+03,
		    1.22279e+00,
  		    4.66147e-04,
  		    2.96494e-05,
  		    -6.21090e-06,
		    1.0,
		    -3.23049e-06
  };

  TLegend *tl = new TLegend(0.25,0.6,0.85,0.8);
  //TLegend *tl = new TLegend(0.462644, 0.651163, 0.862069, 0.852008);
  tl->SetBorderSize(0);

  TFile *f = TFile::Open("hadd_out/hadd.pi.root");
  TEfficiency* eff = (TEfficiency*) f->Get("prob_cut_9/eff1d_mom_e_id");
  tl->AddEntry(eff,"#pi^{#pm} mis-id prob. (p^{EID}_{comb} > 0.9)","pl");

  bool draw_func = false;
  if (draw_func) {
    TFile *f2 = TFile::Open("../new_test/eid90pct/anav2_pip_pim_brem_plab5.5.root");
    TEfficiency* eff2 = (TEfficiency*) f2->Get("pi_eff1d_total_smooth1d_clone");
    TList *list = (TList*) eff2->GetListOfFunctions();
    TF1* fsmth = (TF1*) list->First();
    tl->AddEntry(fsmth,"parametrization");
  }

  TCanvas *tc = new TCanvas("tc","tc");
  tc->cd();
  eff->Draw();
  //
  tc->Update();
  //eff->GetPaintedGraph()->GetHistogram()->SetMinimum(0);
  //eff->GetPaintedGraph()->GetHistogram()->SetMaximum(0.006);
  eff->GetPaintedGraph()->SetMinimum(5e-6);
  eff->GetPaintedGraph()->SetMaximum(0.007);
  eff->Draw();
  //eff->SetTitle(Form("%s;p_{MC}[GeV/c];#varepsilon(#pi^{#pm})^{EID}",eff->GetTitle()));
  //eff->SetTitle(Form("#varepsilon(#pi^{#pm}) for combined eID prob > 90%%;p_{MC}[GeV/c];#varepsilon(#pi^{#pm})^{EID}"));
  eff->SetTitle(Form(";p_{MC}[GeV/c];#varepsilon(#pi^{#pm})^{EID}"));

  set_style(eff->GetPaintedGraph());

  if (draw_func) fsmth->Draw("same");

  gPad->SetLogy();
  tc->Update();

  tl->Draw();

  //TF1* f1 = new TF1("f1",func,0.0001,12,14);
  //for (int ii=0; ii < 14; ++ii) {
  //  if (ii==9||ii==10||ii==11)
  //    f1->FixParameter(ii,pars[ii]);
  //  else
  //    f1->SetParameter(ii,pars[ii]);
  //}
  //eff->Fit(f1,"+RME");
  //eff->Draw();
  //cout << "Eff (0.01)= " << f1->Eval(0.01) << endl;
  //cout << "Eff (0.1)= " << f1->Eval(0.1) << endl;
  //cout << "Eff (0.2)= " << f1->Eval(0.2) << endl;
  //cout << "Eff (0.5)= " << f1->Eval(0.5) << endl;
  //cout << "Eff (1.0)= " << f1->Eval(1.0) << endl;
  //TF1* f2 = new TF1("f1",func,0.0001,12,13);
  //for (int ii=0; ii < 13; ++ii) {
  //  if (ii!=12)
  //    f2->SetParameter(ii,f1->GetParameter(ii));
  //  else
  //    f2->SetParameter(ii,100*f1->GetParameter(ii));
  //}
  //f2->SetLineColor(4);
  //f2->Draw("same");

}
Example #27
0
void YahooParser::tag_start(const QString &tag, const list<QString> &options)
{
    if (tag == "img") {
        QString src;
        for (list<QString>::const_iterator it = options.begin(); it != options.end(); ++it) {
            QString name = (*it);
            ++it;
            QString value = (*it);
            if (name == "src") {
                src = value;
                break;
            }
        }
        if (src.left(10) != "icon:smile")
            return;
        bool bOK;
        unsigned nSmile = src.mid(10).toUInt(&bOK, 16);
        if (!bOK)
            return;
        const smile *p = smiles(nSmile);
        if (p)
            text(p->paste);
        return;
    }
    if (tag == "br") {
        res += "\n";
        return;
    }
    style s = curStyle;
    s.tag = tag;
    tags.push(s);
    if (tag == "p") {
        if (!m_bFirst)
            res += "\n";
        m_bFirst = false;
    }
    if (tag == "font") {
        for (list<QString>::const_iterator it = options.begin(); it != options.end(); ++it) {
            QString name = *it;
            ++it;
            if (name == "color") {
                QColor c;
                c.setNamedColor(*it);
                s.color = c.rgb() & 0xFFFFFF;
            }
        }
    }
    if (tag == "b") {
        s.state |= 1;
        return;
    }
    if (tag == "i") {
        s.state |= 2;
        return;
    }
    if (tag == "u") {
        s.state |= 4;
        return;
    }
    for (list<QString>::const_iterator it = options.begin(); it != options.end(); ++it) {
        QString name = *it;
        ++it;
        if (name != "style")
            continue;
        list<QString> styles = parseStyle(*it);
        for (list<QString>::iterator its = styles.begin(); its != styles.end(); ++its) {
            QString name = *its;
            ++its;
            if (name == "color") {
                QColor c;
                c.setNamedColor(*its);
                s.color = c.rgb() & 0xFFFFFF;
            }
            if (name == "font-size") {
                unsigned size = atol((*its).latin1());
                if (size)
                    s.size = size;
            }
            if (name == "font-family")
                s.face = (*its);
            if (name == "font-weight")
                s.state &= ~1;
            if (atol((*its).latin1()) >= 600)
                s.state |= 1;
            if ((name == "font-style") && ((*its) == "italic"))
                s.state |= 2;
            if ((name == "text-decoration") && ((*its) == "underline"))
                s.state |= 4;
        }
    }
    set_style(s);
}
Example #28
0
void EditorActionChangeParagraphStyle::undo (GtkWidget *& to_focus)
{
  paragraph->style = previous_style;
  set_style (paragraph->style);
  to_focus = paragraph->textview;
}
Example #29
0
void EditorActionChangeParagraphStyle::apply (GtkWidget *& to_focus)
{
  paragraph->style = current_style;
  set_style (paragraph->style);
  to_focus = paragraph->textview;
}
		TITANIUM_PROPERTY_SETTER(ActivityIndicator, style)
		{
			TITANIUM_ASSERT(argument.IsNumber());
			set_style(static_cast<ACTIVITY_INDICATOR_STYLE>(static_cast<std::uint32_t>(argument)));
			return true;
		}