static bool write_foreground_color(unsigned char idx) {
if (set_a_foreground && set_a_foreground[0]) {
return write_color(set_a_foreground, idx, true);
} else if (set_foreground && set_foreground[0]) {
return write_color(set_foreground, idx, true);
} else {
return false;
}
}
static bool write_background_color(unsigned char idx) {
if (set_a_background && set_a_background[0]) {
return write_color(set_a_background, idx, false);
} else if (set_background && set_background[0]) {
return write_color(set_background, idx, false);
} else {
return false;
}
}
static void write_style_defs(FILE *f,const kate_style *ks,size_t indent)
{
char *sindent=(char*)kate_malloc(1+indent);
size_t n;
for (n=0;n<indent;++n) sindent[n]=' ';
sindent[indent]=0;
{
const char *halign=halign2text(ks->halign);
const char *valign=valign2text(ks->valign);
kate_color tc=ks->text_color,bc=ks->background_color,dc=ks->draw_color;
fprintf(
f,
"%s%s %s\n",
sindent,halign,valign
);
write_color(f,"text color",&tc,indent);
write_color(f,"background color",&bc,indent);
write_color(f,"draw color",&dc,indent);
if (ks->font) {
fprintf(f,"%sfont \"%s\"\n",sindent,ks->font);
}
if (ks->font_width>=0 || ks->font_height>=0) {
if (ks->font_width==ks->font_height) {
fprintf(f,"%sfont size %f%s\n",sindent,ks->font_height,metric2suffix(ks->font_metric));
}
else {
if (ks->font_width>=0)
fprintf(f,"%sfont width %f%s\n",sindent,ks->font_width,metric2suffix(ks->font_metric));
if (ks->font_height>=0)
fprintf(f,"%sfont height %f%s\n",sindent,ks->font_height,metric2suffix(ks->font_metric));
}
}
if (ks->left_margin!=0 || ks->top_margin!=0 || ks->right_margin!=0 || ks->bottom_margin!=0) {
const char *margin_metric=metric2suffix(ks->margin_metric);
fprintf(
f,"%smargins %f%s %f%s %f%s %f%s\n",
sindent,
ks->left_margin,margin_metric,ks->top_margin,margin_metric,
ks->right_margin,margin_metric,ks->bottom_margin,margin_metric
);
}
if (ks->bold) fprintf(f,"%sbold\n",sindent);
if (ks->italics) fprintf(f,"%sitalics\n",sindent);
if (ks->underline) fprintf(f,"%sunderline\n",sindent);
if (ks->strike) fprintf(f,"%sstrike\n",sindent);
if (ks->justify) fprintf(f,"%sjustify\n",sindent);
fprintf(f,"%swrap %s\n",sindent,wrap2text(ks->wrap_mode));
if (ks->meta) write_metadata(f,ks->meta,indent);
}
kate_free(sindent);
}
/*
* Fragment shader for surface color based on surface normals.
*/
static void fragment_shader_color(int y, int x, struct fragment_input *input, struct uniform_variables *vars){
if(input->frag_coord[VAR_Z] >= read_depth(y, x)){
return;
}
vec3 object_normal;
object_normal[VAR_X] = input->attributes[0] / input->frag_coord[VAR_W];
object_normal[VAR_Y] = input->attributes[1] / input->frag_coord[VAR_W];
object_normal[VAR_Z] = input->attributes[2] / input->frag_coord[VAR_W];
normalize_vec3(object_normal);
if(input->front_facing == ER_FALSE){
object_normal[VAR_X] = -object_normal[VAR_X];
object_normal[VAR_Y] = -object_normal[VAR_Y];
object_normal[VAR_Z] = -object_normal[VAR_Z];
}
float red, green, blue;
red = (object_normal[VAR_X] * 0.5f + 0.5f);
red = clamp(red, 0.0f, 1.0f);
green = (object_normal[VAR_Y] * 0.5f + 0.5f);
green = clamp(green, 0.0f, 1.0f);
blue = (object_normal[VAR_X] * 0.5f + 0.5f);
blue = clamp(blue, 0.0f, 1.0f);
write_color(y, x, red, green, blue, 1.0f);
write_depth(y, x, input->frag_coord[VAR_Z]);
}
/*
* Fragment shader for axis and arrows.
*/
static void fragment_shader_axis(int y, int x, struct fragment_input *input, struct uniform_variables *vars){
if(input->frag_coord[VAR_Z] >= read_depth(y, x)){
return;
}
write_color(y, x, input->attributes[0], input->attributes[1], input->attributes[2], 1.0f);
write_depth(y, x, input->frag_coord[VAR_Z]);
}
bool PymolWriter::handle_point(PointGeometry *g, Color color,
std::string name) {
setup(name, OTHER);
write_color(get_stream(), color);
get_stream() << "SPHERE, " << algebra::commas_io(g->get_geometry()) << ", "
<< .1 << ",\n";
return true;
}
void
SaveColor(struct MyGadget *gd)
{
write_integer(gd->data.col.cellsize);
write_integer(gd->data.col.layout);
write_integer(gd->data.col.redrawbuffer);
write_color(&gd->data.col.value);
}
bool PymolWriter::handle_sphere(SphereGeometry *g, Color color,
std::string name) {
setup(name, OTHER);
write_color(get_stream(), color);
get_stream() << "SPHERE, "
<< algebra::commas_io(g->get_geometry().get_center()) << ", "
<< g->get_geometry().get_radius() << ",\n";
return true;
}
void
SaveSlider(struct MyGadget *gd)
{
write_integer(gd->data.bslider.min);
write_integer(gd->data.bslider.max);
write_integer(gd->data.bslider.pos);
write_integer(gd->data.bslider.style);
write_integer(gd->data.bslider.hashtype);
write_integer(gd->data.bslider.hashcount);
write_integer(gd->data.bslider.thickness);
write_integer(gd->data.bslider.keyinc);
write_integer(gd->data.bslider.fillall);
write_color(&gd->data.bslider.fillcolor);
write_color(&gd->data.bslider.barcolor);
write_string(&gd->data.bslider.Label[0]);
write_string(&gd->data.bslider.MinLabel[0]);
write_string(&gd->data.bslider.MaxLabel[0]);
}
void
SaveStatus(struct MyGadget *gd)
{
write_integer(gd->data.sta.barheight);
write_integer(gd->data.sta.maxvalue);
write_integer(gd->data.sta.value);
write_color(&gd->data.sta.barcolor);
write_string(&gd->data.sta.Label[0]);
write_string(&gd->data.sta.Trail[0]);
}
/*
* Fragment shader for surface lighting. One directional light source, phong shading.
*/
static void fragment_shader_light(int y, int x, struct fragment_input *input, struct uniform_variables *vars){
if(input->frag_coord[VAR_Z] >= read_depth(y, x)){
return;
}
float *light_dir = &(vars->uniform_float[0]);
vec3 eye_normal, object_normal;
object_normal[VAR_X] = input->attributes[0] / input->frag_coord[VAR_W];
object_normal[VAR_Y] = input->attributes[1] / input->frag_coord[VAR_W];
object_normal[VAR_Z] = input->attributes[2] / input->frag_coord[VAR_W];
eye_normal[VAR_X] = input->attributes[3] / input->frag_coord[VAR_W];
eye_normal[VAR_Y] = input->attributes[4] / input->frag_coord[VAR_W];
eye_normal[VAR_Z] = input->attributes[5] / input->frag_coord[VAR_W];
normalize_vec3(eye_normal);
normalize_vec3(object_normal);
if(input->front_facing == ER_FALSE){
eye_normal[VAR_X] = -eye_normal[VAR_X];
eye_normal[VAR_Y] = -eye_normal[VAR_Y];
eye_normal[VAR_Z] = -eye_normal[VAR_Z];
object_normal[VAR_X] = -object_normal[VAR_X];
object_normal[VAR_Y] = -object_normal[VAR_Y];
object_normal[VAR_Z] = -object_normal[VAR_Z];
}
float diffuse_term = max(0.0f, dot_vec3(light_dir, eye_normal) );
float specular_term = 0.0f;
vec3 view_vector;
vec3 half_vector;
view_vector[VAR_X] = 0.0f;
view_vector[VAR_Y] = 0.0f;
view_vector[VAR_Z] = 1.0f;
if(diffuse_term > 0.0f){
half_vector[VAR_X] = light_dir[VAR_X] + view_vector[VAR_X];
half_vector[VAR_Y] = light_dir[VAR_Y] + view_vector[VAR_Y];
half_vector[VAR_Z] = light_dir[VAR_Z] + view_vector[VAR_Z];
normalize_vec3(half_vector);
specular_term = pow( max(0.0f, dot_vec3(half_vector, eye_normal)), 50.0f );
}
float red, green, blue, light_intensity;
light_intensity = 0.6f * diffuse_term + 0.4f * specular_term;
red = (object_normal[VAR_X] * 0.5f + 0.5f) * light_intensity;
red = clamp(red, 0.0f, 1.0f);
green = (object_normal[VAR_Y] * 0.5f + 0.5f) * light_intensity;
green = clamp(green, 0.0f, 1.0f);
blue = (object_normal[VAR_Z] * 0.5f + 0.5f) * light_intensity;
blue = clamp(blue, 0.0f, 1.0f);
write_color(y, x, red, green, blue, 1.0f);
write_depth(y, x, input->frag_coord[VAR_Z]);
}
/*
* Fragment shader for texture mapped cube.
*/
static void fs_cube(int y, int x, struct fragment_input *input, struct uniform_variables *vars){
if(input->frag_coord[VAR_Z] >= read_depth(y, x)){
return;
}
struct texture* tex = vars->uniform_texture[0];
vec2 tex_coord;
vec4 tex_color;
tex_coord[VAR_S] = input->attributes[0] / input->frag_coord[VAR_W];
tex_coord[VAR_T] = input->attributes[1] / input->frag_coord[VAR_W];
texture_lod(tex, tex_coord, 0.0f, tex_color);
write_color(y, x, tex_color[0], tex_color[1], tex_color[2], 1.0f);
write_depth(y, x, input->frag_coord[VAR_Z]);
}
bool PymolWriter::handle_cylinder(CylinderGeometry *g, Color color,
std::string name) {
setup(name, OTHER);
write_color(get_stream(), color);
// cleanup(name, false);
get_stream() << "CYLINDER,\n"
<< algebra::commas_io(
g->get_geometry().get_segment().get_point(0)) << ",\n"
<< algebra::commas_io(g->get_geometry().get_segment().get_point(
1)) << ",\n" << g->get_geometry().get_radius() << ",\n";
get_stream() << color.get_red() << ", " << color.get_green() << ", "
<< color.get_blue() << ",\n";
get_stream() << color.get_red() << ", " << color.get_green() << ", "
<< color.get_blue() << ",\n";
return true;
}
bool PymolWriter::handle_segment(SegmentGeometry *g, Color color,
std::string name) {
setup(name, LINES);
/*double r= .01*(g->get_geometry().get_point(0)- g->get_geometry()
.get_point(1)).get_magnitude();*/
if (!open_type_) {
get_stream() << "BEGIN, LINES,\n";
open_type_ = LINES;
}
write_color(get_stream(), color);
get_stream() << "VERTEX, "
<< algebra::commas_io(g->get_geometry().get_point(0)) << ",\n"
<< "VERTEX, "
<< algebra::commas_io(g->get_geometry().get_point(1)) << ",\n";
//<< "END,\n";
return true;
}
/*
* Fragment shader for texture mapped cube. Calculation of perspective correct derivatives for trilinear filtering.
*/
static void fs_cube_grad(int y, int x, struct fragment_input *input, struct uniform_variables *vars){
if(input->frag_coord[VAR_Z] >= read_depth(y, x)){
return;
}
struct texture *tex = vars->uniform_texture[0];
vec2 tex_coord;
vec4 tex_color;
tex_coord[VAR_S] = input->attributes[0] / input->frag_coord[VAR_W];
tex_coord[VAR_T] = input->attributes[1] / input->frag_coord[VAR_W];
vec2 ddx, ddy;
float one_over_w2 = 1.0f / (input->frag_coord[VAR_W] * input->frag_coord[VAR_W]);
ddx[VAR_S] = (input->ddx[0] * input->frag_coord[VAR_W] - input->attributes[0] * input->dw_dx) * one_over_w2;
ddx[VAR_T] = (input->ddx[1] * input->frag_coord[VAR_W] - input->attributes[1] * input->dw_dx) * one_over_w2;
ddy[VAR_S] = (input->ddy[0] * input->frag_coord[VAR_W] - input->attributes[0] * input->dw_dy) * one_over_w2;
ddy[VAR_T] = (input->ddy[1] * input->frag_coord[VAR_W] - input->attributes[1] * input->dw_dy) * one_over_w2;
texture_grad(tex, tex_coord, ddx, ddy, tex_color);
write_color(y, x, tex_color[0], tex_color[1], tex_color[2], 1.0f);
write_depth(y, x, input->frag_coord[VAR_Z]);
}
/**
set_color builtin
*/
static int builtin_set_color(parser_t &parser, wchar_t **argv)
{
/** Variables used for parsing the argument list */
const struct woption long_options[] =
{
{ L"background", required_argument, 0, 'b'},
{ L"help", no_argument, 0, 'h' },
{ L"bold", no_argument, 0, 'o' },
{ L"underline", no_argument, 0, 'u' },
{ L"version", no_argument, 0, 'v' },
{ L"print-colors", no_argument, 0, 'c' },
{ 0, 0, 0, 0 }
};
const wchar_t *short_options = L"b:hvocu";
int argc = builtin_count_args(argv);
/* Some code passes variables to set_color that don't exist, like $fish_user_whatever. As a hack, quietly return failure. */
if (argc <= 1)
{
return EXIT_FAILURE;
}
const wchar_t *bgcolor = NULL;
bool bold = false, underline=false;
int errret;
/* Parse options to obtain the requested operation and the modifiers */
woptind = 0;
while (1)
{
int c = wgetopt_long(argc, argv, short_options, long_options, 0);
if (c == -1)
{
break;
}
switch (c)
{
case 0:
break;
case 'b':
bgcolor = woptarg;
break;
case 'h':
builtin_print_help(parser, argv[0], stdout_buffer);
return STATUS_BUILTIN_OK;
case 'o':
bold = true;
break;
case 'u':
underline = true;
break;
case 'c':
print_colors();
return STATUS_BUILTIN_OK;
case '?':
return STATUS_BUILTIN_ERROR;
}
}
/* Remaining argument is foreground color */
const wchar_t *fgcolor = NULL;
if (woptind < argc)
{
if (woptind + 1 == argc)
{
fgcolor = argv[woptind];
}
else
{
append_format(stderr_buffer,
_(L"%ls: Too many arguments\n"),
argv[0]);
return STATUS_BUILTIN_ERROR;
}
}
if (fgcolor == NULL && bgcolor == NULL && !bold && !underline)
{
append_format(stderr_buffer,
_(L"%ls: Expected an argument\n"),
argv[0]);
return STATUS_BUILTIN_ERROR;
}
const rgb_color_t fg = rgb_color_t(fgcolor ? fgcolor : L"");
if (fgcolor && (fg.is_none() || fg.is_ignore()))
{
append_format(stderr_buffer, _(L"%ls: Unknown color '%ls'\n"), argv[0], fgcolor);
return STATUS_BUILTIN_ERROR;
}
const rgb_color_t bg = rgb_color_t(bgcolor ? bgcolor : L"");
if (bgcolor && (bg.is_none() || bg.is_ignore()))
{
append_format(stderr_buffer, _(L"%ls: Unknown color '%ls'\n"), argv[0], bgcolor);
return STATUS_BUILTIN_ERROR;
}
/* Make sure that the term exists */
if (cur_term == NULL && setupterm(0, STDOUT_FILENO, &errret) == ERR)
{
append_format(stderr_buffer, _(L"%ls: Could not set up terminal\n"), argv[0]);
return STATUS_BUILTIN_ERROR;
}
/*
Test if we have at least basic support for setting fonts, colors
and related bits - otherwise just give up...
*/
if (! exit_attribute_mode)
{
return STATUS_BUILTIN_ERROR;
}
/* Save old output function so we can restore it */
int (* const saved_writer_func)(char) = output_get_writer();
/* Set our output function, which writes to a std::string */
builtin_set_color_output.clear();
output_set_writer(set_color_builtin_outputter);
if (bold)
{
if (enter_bold_mode)
writembs(tparm(enter_bold_mode));
}
if (underline)
{
if (enter_underline_mode)
writembs(enter_underline_mode);
}
if (bgcolor != NULL)
{
if (bg.is_normal())
{
write_color(rgb_color_t::black(), false /* not is_fg */);
writembs(tparm(exit_attribute_mode));
}
}
if (fgcolor != NULL)
{
if (fg.is_normal() || fg.is_reset())
{
write_color(rgb_color_t::black(), true /* is_fg */);
writembs(tparm(exit_attribute_mode));
}
else
{
write_color(fg, true /* is_fg */);
}
}
if (bgcolor != NULL)
{
if (! bg.is_normal() && ! bg.is_reset())
{
write_color(bg, false /* not is_fg */);
}
}
/* Restore saved writer function */
output_set_writer(saved_writer_func);
/* Output the collected string */
stdout_buffer.append(str2wcstring(builtin_set_color_output));
builtin_set_color_output.clear();
return STATUS_BUILTIN_OK;
}
int main(int argc, char *argv[]) {
int fd; /* SPI device file descriptor */
const int leds = 50; /* 50 LEDs in the strand */
tcl_buffer buf; /* Memory buffer for pixel values */
int count; /* Count of iterations (up to 3) */
int i; /* Counting Integer */
/* Open SPI device */
fd = open(device,O_WRONLY);
if(fd<0) {
/* Open failed */
fprintf(stderr, "Error: SPI device open failed.\n");
exit(1);
}
/* Initialize SPI bus for TCL pixels */
if(spi_init(fd)<0) {
/* Initialization failed */
fprintf(stderr, "Unable to initialize SPI bus.\n");
exit(1);
}
/* Allocate memory for the pixel buffer and initialize it */
if(tcl_init(&buf,leds)<0) {
/* Memory allocation failed */
fprintf(stderr, "Insufficient memory for pixel buffer.\n");
exit(1);
}
/* Loop Forever */
while(1) {
/* Do three iterations */
for(count=0;count<3;count++) {
/* Write color for every pixel */
for(i=0;i<leds;i++) {
if((i+count)%3==0) {
/* Red pixel */
write_color(&buf.pixels[i],255,0,0);
}
else if((i+count)%3==1) {
/* Green pixel */
write_color(&buf.pixels[i],0,255,0);
}
else {
/* Blue pixel */
write_color(&buf.pixels[i],0,0,255);
}
}
/* Send the data to the TCL lighting strand */
if(send_buffer(fd,&buf)<0) {
fprintf(stderr, "Error sending data.\n");
exit(1);
}
/* Sleep for 1 second */
usleep(1000000);
}
}
/* Although the program never gets to this point, below is how to clean up */
/* Free the pixel buffer */
tcl_free(&buf);
/* Close the SPI device */
close(fd);
return 0;
}
int main(int argc, char* argv[]) {
struct controller controller;
glob_t pglob;
char *device;
glob("/sys/class/input/js*", 0, 0, &pglob);
if (pglob.gl_pathc == 0) {
sprintf(err, "Could not enumerate any input devices");
return 0;
}
for (size_t i = 0; i < pglob.gl_pathc; ++i) {
device = pglob.gl_pathv[i];
if (!read_controller(device, &controller)) {
fatal();
}
else {
/* controller.capacity = 20; */
float percent = controller.capacity / 100.f;
printf("\ndevice: %s\n", device);
printf("capacity: %d\n", controller.capacity);
float scale = 255 * percent;
printf("writing %f\n", scale);
if (controller.capacity <= 10) {
write_trigger(device, "heartbeat");
}
else {
write_trigger(device, "none");
write_color(device, "global", 1);
}
if (controller.capacity < 25) {
if (!write_color(device, "red", 10)) fatal();
if (!write_color(device, "green", 0)) fatal();
if (!write_color(device, "blue", 0)) fatal();
}
else if (controller.capacity < 50) {
if (!write_color(device, "red", 10)) fatal();
if (!write_color(device, "green", 5)) fatal();
if (!write_color(device, "blue", 0)) fatal();
}
else if (controller.capacity < 75 ) {
if (!write_color(device, "red", 10)) fatal();
if (!write_color(device, "green", 10)) fatal();
if (!write_color(device, "blue", 0)) fatal();
}
else if (controller.capacity < 100 ) {
if (!write_color(device, "red", 0)) fatal();
if (!write_color(device, "green", 10)) fatal();
if (!write_color(device, "blue", 0)) fatal();
}
else if (controller.capacity >= 100 ) {
if (!write_color(device, "red", 0)) fatal();
if (!write_color(device, "green", 0)) fatal();
if (!write_color(device, "blue", 10)) fatal();
}
}
}
globfree(&pglob);
return 0;
}
/// set_color builtin.
int builtin_set_color(parser_t &parser, io_streams_t &streams, wchar_t **argv) {
wgetopter_t w;
// Variables used for parsing the argument list.
const struct woption long_options[] = {{L"background", required_argument, 0, 'b'},
{L"help", no_argument, 0, 'h'},
{L"bold", no_argument, 0, 'o'},
{L"underline", no_argument, 0, 'u'},
{L"version", no_argument, 0, 'v'},
{L"print-colors", no_argument, 0, 'c'},
{0, 0, 0, 0}};
const wchar_t *short_options = L"b:hvocu";
int argc = builtin_count_args(argv);
// Some code passes variables to set_color that don't exist, like $fish_user_whatever. As a
// hack, quietly return failure.
if (argc <= 1) {
return EXIT_FAILURE;
}
const wchar_t *bgcolor = NULL;
bool bold = false, underline = false;
int errret;
// Parse options to obtain the requested operation and the modifiers.
w.woptind = 0;
while (1) {
int c = w.wgetopt_long(argc, argv, short_options, long_options, 0);
if (c == -1) {
break;
}
switch (c) {
case 0: {
break;
}
case 'b': {
bgcolor = w.woptarg;
break;
}
case 'h': {
builtin_print_help(parser, streams, argv[0], streams.out);
return STATUS_BUILTIN_OK;
}
case 'o': {
bold = true;
break;
}
case 'u': {
underline = true;
break;
}
case 'c': {
print_colors(streams);
return STATUS_BUILTIN_OK;
}
case '?': {
return STATUS_BUILTIN_ERROR;
}
}
}
// Remaining arguments are foreground color.
std::vector<rgb_color_t> fgcolors;
for (; w.woptind < argc; w.woptind++) {
rgb_color_t fg = rgb_color_t(argv[w.woptind]);
if (fg.is_none()) {
streams.err.append_format(_(L"%ls: Unknown color '%ls'\n"), argv[0], argv[w.woptind]);
return STATUS_BUILTIN_ERROR;
}
fgcolors.push_back(fg);
}
if (fgcolors.empty() && bgcolor == NULL && !bold && !underline) {
streams.err.append_format(_(L"%ls: Expected an argument\n"), argv[0]);
return STATUS_BUILTIN_ERROR;
}
// #1323: We may have multiple foreground colors. Choose the best one. If we had no foreground
// color, we'll get none(); if we have at least one we expect not-none.
const rgb_color_t fg = best_color(fgcolors, output_get_color_support());
assert(fgcolors.empty() || !fg.is_none());
const rgb_color_t bg = rgb_color_t(bgcolor ? bgcolor : L"");
if (bgcolor && bg.is_none()) {
streams.err.append_format(_(L"%ls: Unknown color '%ls'\n"), argv[0], bgcolor);
return STATUS_BUILTIN_ERROR;
}
// Make sure that the term exists.
if (cur_term == NULL && setupterm(0, STDOUT_FILENO, &errret) == ERR) {
streams.err.append_format(_(L"%ls: Could not set up terminal\n"), argv[0]);
return STATUS_BUILTIN_ERROR;
}
// Test if we have at least basic support for setting fonts, colors and related bits - otherwise
// just give up...
if (!exit_attribute_mode) {
return STATUS_BUILTIN_ERROR;
}
// Save old output function so we can restore it.
int (*const saved_writer_func)(char) = output_get_writer();
// Set our output function, which writes to a std::string.
builtin_set_color_output.clear();
output_set_writer(set_color_builtin_outputter);
if (bold) {
if (enter_bold_mode) writembs(tparm(enter_bold_mode));
}
if (underline) {
if (enter_underline_mode) writembs(enter_underline_mode);
}
if (bgcolor != NULL) {
if (bg.is_normal()) {
write_color(rgb_color_t::black(), false /* not is_fg */);
writembs(tparm(exit_attribute_mode));
}
}
if (!fg.is_none()) {
if (fg.is_normal() || fg.is_reset()) {
write_color(rgb_color_t::black(), true /* is_fg */);
writembs(tparm(exit_attribute_mode));
} else {
write_color(fg, true /* is_fg */);
}
}
if (bgcolor != NULL) {
if (!bg.is_normal() && !bg.is_reset()) {
write_color(bg, false /* not is_fg */);
}
}
// Restore saved writer function.
output_set_writer(saved_writer_func);
// Output the collected string.
streams.out.append(str2wcstring(builtin_set_color_output));
builtin_set_color_output.clear();
return STATUS_BUILTIN_OK;
}
