Esempio n. 1
0
static void stpui_spin_changed(GtkWidget *w,gpointer *ud)
{
	stpui_Slider *s=STPUI_SLIDER(ud);
	double value;
	
	switch(s->type)
	{
		case STP_PARAMETER_TYPE_DOUBLE:
			value=gtk_spin_button_get_value(GTK_SPIN_BUTTON(s->spin));
			stp_set_float_parameter(s->vars,s->optionname,value);
			break;
		case STP_PARAMETER_TYPE_INT:
			value=gtk_spin_button_get_value(GTK_SPIN_BUTTON(s->spin));
			stp_set_int_parameter(s->vars,s->optionname,value);
			break;
		case STP_PARAMETER_TYPE_DIMENSION:
			value=dimension_get_pt(DIMENSION(s->spin));
			stp_set_dimension_parameter(s->vars,s->optionname,value);
			break;
		default:
			break;
	}	

	stpui_slider_refresh(s);

//	g_signal_emit(G_OBJECT (s),
//		stpui_slider_signals[CHANGED_SIGNAL], 0);
}
Esempio n. 2
0
static void stpui_slider_changed(GtkWidget *w,gpointer *ud)
{
	stpui_Slider *s=STPUI_SLIDER(ud);
	double value;
	
	if(s->checkbutton)
		gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(s->checkbutton),TRUE);

	switch(s->type)
	{
		case STP_PARAMETER_TYPE_DOUBLE:
			value=gtk_range_get_value(GTK_RANGE(s->scale));
			stp_set_float_parameter(s->vars,s->optionname,value);
			break;
		case STP_PARAMETER_TYPE_INT:
			value=gtk_range_get_value(GTK_RANGE(s->scale));
			stp_set_int_parameter(s->vars,s->optionname,value);
			break;
		case STP_PARAMETER_TYPE_DIMENSION:
			value=gtk_range_get_value(GTK_RANGE(s->scale));
			stp_set_dimension_parameter(s->vars,s->optionname,value);
			break;
		default:
			break;
	}

	stpui_slider_refresh(s);

//	g_signal_emit(G_OBJECT (s),
//		stpui_slider_signals[CHANGED_SIGNAL], 0);
}
Esempio n. 3
0
static gboolean stpui_slider_released(GtkWidget *w,GdkEventButton *e,gpointer ud)
{
	stpui_Slider *s=STPUI_SLIDER(ud);
	double value;

	switch(s->type)
	{
		case STP_PARAMETER_TYPE_DOUBLE:
			value=gtk_range_get_value(GTK_RANGE(s->scale));
			stp_set_float_parameter(s->vars,s->optionname,value);
			break;
		case STP_PARAMETER_TYPE_INT:
			value=gtk_range_get_value(GTK_RANGE(s->scale));
			stp_set_int_parameter(s->vars,s->optionname,value);
			break;
		case STP_PARAMETER_TYPE_DIMENSION:
			value=gtk_range_get_value(GTK_RANGE(s->scale));
			stp_set_dimension_parameter(s->vars,s->optionname,value);
			break;
		default:
			break;
	}	

	stpui_slider_refresh(s);

	g_signal_emit(G_OBJECT (s),
		stpui_slider_signals[CHANGED_SIGNAL], 0);

	return(FALSE);
}
Esempio n. 4
0
static void stpui_toggle_changed(GtkWidget *w,gpointer *ud)
{
	stpui_Slider *s=STPUI_SLIDER(ud);

	gboolean enabled=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(s->checkbutton));
	if(enabled)
	{
		stp_parameter_t desc;
		stp_describe_parameter(s->vars,s->optionname,&desc);
		switch(desc.p_type)
		{
			case STP_PARAMETER_TYPE_DOUBLE:
				{
					double val=gtk_range_get_value(GTK_RANGE(s->scale));
					stp_set_float_parameter(s->vars,s->optionname,val);
				}
				break;
			case STP_PARAMETER_TYPE_INT:
				{
					double val=gtk_range_get_value(GTK_RANGE(s->scale));
					stp_set_int_parameter(s->vars,s->optionname,val);
				}
				break;
			case STP_PARAMETER_TYPE_DIMENSION:
				{
					double val=gtk_range_get_value(GTK_RANGE(s->scale));
					// Convert to correct unit here
					stp_set_dimension_parameter(s->vars,s->optionname,val);
				}
				break;
			default:
				break;	
		}
	}
	else
	{
		stp_parameter_t desc;
		stp_describe_parameter(s->vars,s->optionname,&desc);
		switch(desc.p_type)
		{
			case STP_PARAMETER_TYPE_DOUBLE:
				stp_clear_float_parameter(s->vars,s->optionname);
				break;
			case STP_PARAMETER_TYPE_INT:
				stp_clear_int_parameter(s->vars,s->optionname);
				break;
			case STP_PARAMETER_TYPE_DIMENSION:
				stp_clear_dimension_parameter(s->vars,s->optionname);
				break;
			default:
				break;	
		}		
	}
	
	stpui_slider_refresh(s);
}
void guten_set_user_parameters(struct stp_vars* gvars, char **params, unsigned int params_num) {
	int i;
	for(i=0; i<params_num; i++) {
		stp_parameter_t pardesc;
		char* name = params[2*i];
		char* value = params[2*i +1];
		stp_describe_parameter(gvars, name, &pardesc);
		switch(pardesc.p_type) {
			case STP_PARAMETER_TYPE_STRING_LIST: {
				stp_set_string_parameter(gvars, pardesc.name, value);
				break;
			}
			case STP_PARAMETER_TYPE_INT: {
			        int ival;
                                if(sscanf(value, "%d", &ival)) {
                                        stp_set_int_parameter(gvars, pardesc.name, ival);
                                } else {
                                        printf("Cannot parse gutenprint int parameter %s=%s - skipping\n", name, value);
                                }
                                break;
                        }
                        case STP_PARAMETER_TYPE_BOOLEAN: {
			        boolean bval;
			        boolean correct = FALSE;
			        if(strcasecmp(value, "true") == 0 || strcasecmp(value, "yes") == 0 || strcmp(value, "1") == 0) {
			                bval = TRUE;
			                correct = TRUE;
			        }
			        else if(strcasecmp(value, "false") == 0 || strcasecmp(value, "no") == 0 || strcmp(value, "0") == 0) {
			                bval = FALSE;
			                correct = TRUE;
			        }
                                if(correct) {
                                        stp_set_boolean_parameter(gvars, pardesc.name, bval);
                                } else {
                                        printf("Cannot parse gutenprint boolean parameter %s=%s - skipping\n", name, value);
                                }
				break;
			}
			case STP_PARAMETER_TYPE_DOUBLE: {
			        double dval;
                                if(sscanf(value, "%lf", &dval)) {
                                        stp_set_float_parameter(gvars, pardesc.name, dval);
                                } else {
                                        printf("Cannot parse gutenprint double parameter %s=%s - skipping\n", name, value);
                                }
				break;
			}
			case STP_PARAMETER_TYPE_CURVE: {
			        printf("Gutenprint curve parameter %s - skipping, freel free to write a curve parser for this tool\n", name);
				break;
			}
			case STP_PARAMETER_TYPE_FILE: {
				stp_set_file_parameter(gvars, pardesc.name, value);
				break;
			}
			case STP_PARAMETER_TYPE_RAW: {
			        printf("Gutenprint raw parameter %s - skipping, freel free to write an implementation to support raw parameter in this tool\n", name);
				break;
			}
			case STP_PARAMETER_TYPE_ARRAY: {
			        printf("Gutenprint array parameter %s - skipping, freel free to write an implementation to support arra parameter in this tool\n", name);
				break;
			}
			case STP_PARAMETER_TYPE_DIMENSION: {
			        int ival;
                                if(sscanf(value, "%d", &ival)) {
                                        stp_set_dimension_parameter(gvars, pardesc.name, ival);
                                } else {
                                        printf("Cannot parse gutenprint dimension parameter %s=%s - skipping\n", name, value);
                                }
                                break;
			}
			default: {
			        printf("Gutenprint parameter %s has unknown type - skippig\n", name);
			}
                }
	}
}
struct stp_vars *guten_prepare_printer(const stp_printer_t *printer) {
        const struct stp_vars *gvars_defaults;
        struct stp_vars *gvars;

	gvars_defaults = stp_printer_get_defaults(printer);
	gvars = stp_vars_create_copy(gvars_defaults);
	stp_set_outdata(gvars, stdout);
	stp_set_outfunc(gvars, gfunc_print);
	stp_set_errdata(gvars, stderr);
	stp_set_errfunc(gvars, gfunc_error);
	stp_parameter_list_t *list = stp_get_parameter_list(gvars);
	size_t count = stp_parameter_list_count(list);
	int i;
	for(i=0; i<count; i++) {
		const stp_parameter_t *par = stp_parameter_list_param(list, i);
		stp_parameter_t pardesc;
		stp_describe_parameter(gvars, par->name, &pardesc);
		if(pardesc.is_mandatory) {
			switch(pardesc.p_type) {
				case STP_PARAMETER_TYPE_STRING_LIST: {
					stp_set_string_parameter(gvars, pardesc.name, pardesc.deflt.str);
					break;
				}
				case STP_PARAMETER_TYPE_INT: {
					stp_set_int_parameter(gvars, pardesc.name, pardesc.deflt.integer);
					break;
				}
				case STP_PARAMETER_TYPE_BOOLEAN: {
					stp_set_boolean_parameter(gvars, pardesc.name, pardesc.deflt.boolean);
					break;
				}
				case STP_PARAMETER_TYPE_DOUBLE: {
					stp_set_float_parameter(gvars, pardesc.name, pardesc.deflt.dbl);
					break;
				}
				case STP_PARAMETER_TYPE_CURVE: {
					stp_set_curve_parameter(gvars, pardesc.name, pardesc.deflt.curve);
					break;
				}
				case STP_PARAMETER_TYPE_FILE: {
					stp_set_file_parameter(gvars, pardesc.name, pardesc.deflt.str);
					break;
				}
/*				case STP_PARAMETER_TYPE_RAW: {
					stp_set_raw_parameter(gvars, pardesc.name, pardesc.deflt.str);
					break;
				}
*/
				case STP_PARAMETER_TYPE_ARRAY: {
					stp_set_array_parameter(gvars, pardesc.name, pardesc.deflt.array);
					break;
				}
				case STP_PARAMETER_TYPE_DIMENSION: {
					stp_set_dimension_parameter(gvars, pardesc.name, pardesc.deflt.dimension);
					break;
				}
				default: {}
			}
		}
	}
	stp_parameter_list_destroy(list);
	return gvars;
}
Esempio n. 7
0
static int
do_print(void)
{
  int status = 0;
  stp_vars_t *v;
  const stp_printer_t *the_printer;
  int left, right, top, bottom;
  int x, y;
  int width, height;
  int retval;
  stp_parameter_list_t params;
  int count;
  int i;
  char tmp[32];

  initialize_global_parameters();
  global_vars = stp_vars_create();
  stp_set_outfunc(global_vars, writefunc);
  stp_set_errfunc(global_vars, writefunc);
  stp_set_outdata(global_vars, stdout);
  stp_set_errdata(global_vars, stderr);

  setlocale(LC_ALL, "C");
  retval = yyparse();
  setlocale(LC_ALL, "");
  if (retval)
    return retval + 1;

  if (!global_did_something)
    return 1;

  v = stp_vars_create();
  the_printer = stp_get_printer_by_driver(global_printer);
  if (!the_printer)
    {
      int j;
      fprintf(stderr, "Unknown printer %s\nValid printers are:\n",
	      global_printer);
      for (j = 0; j < stp_printer_model_count(); j++)
	{
	  the_printer = stp_get_printer_by_index(j);
	  fprintf(stderr, "%-16s%s\n", stp_printer_get_driver(the_printer),
		  stp_printer_get_long_name(the_printer));
	}
      return 2;
    }
  bytes_written = 0;
  if (global_output)
    {
      if (strcmp(global_output, "-") == 0)
	output = stdout;
      else if (strcmp(global_output, "") == 0)
	output = NULL;
      else if (global_output[0] == '|')
	{
	  close_output();
	  write_to_process = 1;
	  output = popen(global_output+1, "w");
	  if (! output)
	    {
	      fprintf(stderr, "popen '%s' failed: %s\n", global_output, strerror(errno));
	      output = NULL;
	    }
	  free(global_output);
	  global_output = NULL;
	}
      else
	{
	  close_output();
	  output = fopen(global_output, "wb");
	  if (! output)
	    {
	      fprintf(stderr, "Create %s failed: %s\n", global_output, strerror(errno));
	      output = NULL;
	    }
	  free(global_output);
	  global_output = NULL;
	}
    }
  stp_set_printer_defaults(v, the_printer);
  stp_set_outfunc(v, writefunc);
  stp_set_errfunc(v, writefunc);
  stp_set_outdata(v, output);
  stp_set_errdata(v, stderr);
  stp_set_string_parameter(v, "InputImageType", global_image_type);
  sprintf(tmp, "%d", global_bit_depth);
  stp_set_string_parameter(v, "ChannelBitDepth", tmp);
  if (strcmp(global_image_type, "Raw") == 0)
    {
      sprintf(tmp, "%d", global_channel_depth);
      stp_set_string_parameter(v, "RawChannels", tmp);
    }
  stp_set_float_parameter(v, "Density", global_density);
  stp_set_string_parameter(v, "Quality", "None");
  stp_set_string_parameter(v, "ImageType", "None");

  params = stp_get_parameter_list(v);
  count = stp_parameter_list_count(params);
  for (i = 0; i < count; i++)
    {
      const stp_parameter_t *p = stp_parameter_list_param(params, i);
      if (p->p_type == STP_PARAMETER_TYPE_STRING_LIST)
	{
	  const char *val = stp_get_string_parameter(global_vars, p->name);
	  if (val && strlen(val) > 0)
	    {
	      stp_set_string_parameter(v, p->name, val);
	    }
	}
      else if (p->p_type == STP_PARAMETER_TYPE_INT &&
	       stp_check_int_parameter(global_vars, p->name, STP_PARAMETER_ACTIVE))
	{
	  int val = stp_get_int_parameter(global_vars, p->name);
	  stp_set_int_parameter(v, p->name, val);
	}
      else if (p->p_type == STP_PARAMETER_TYPE_BOOLEAN &&
	       stp_check_boolean_parameter(global_vars, p->name, STP_PARAMETER_ACTIVE))
	{
	  int val = stp_get_boolean_parameter(global_vars, p->name);
	  stp_set_boolean_parameter(v, p->name, val);
	}
      else if (p->p_type == STP_PARAMETER_TYPE_CURVE &&
	       stp_check_curve_parameter(global_vars, p->name, STP_PARAMETER_ACTIVE))
	{
	  const stp_curve_t *val = stp_get_curve_parameter(global_vars, p->name);
	  stp_set_curve_parameter(v, p->name, val);
	}
      else if (p->p_type == STP_PARAMETER_TYPE_DOUBLE &&
	       stp_check_float_parameter(global_vars, p->name, STP_PARAMETER_ACTIVE))
	{
	  double val = stp_get_float_parameter(global_vars, p->name);
	  stp_set_float_parameter(v, p->name, val);
	}
    }
  stp_set_page_width(v, stp_get_page_width(global_vars));
  stp_set_page_height(v, stp_get_page_height(global_vars));
  stp_parameter_list_destroy(params);
  if (stp_check_string_parameter(v, "PageSize", STP_PARAMETER_ACTIVE) &&
      !strcmp(stp_get_string_parameter(v, "PageSize"), "Auto"))
    {
      stp_parameter_t desc;
      stp_describe_parameter(v, "PageSize", &desc);
      if (desc.p_type == STP_PARAMETER_TYPE_STRING_LIST)
	stp_set_string_parameter(v, "PageSize", desc.deflt.str);
      stp_parameter_description_destroy(&desc);
    }
  stp_set_printer_defaults_soft(v, the_printer);

  stp_get_imageable_area(v, &left, &right, &bottom, &top);
  stp_describe_resolution(v, &x, &y);
  if (x < 0)
    x = 300;
  if (y < 0)
    y = 300;

  width = right - left;
  height = bottom - top;

  switch (global_size_mode)
    {
    case SIZE_PT:
      top += (int) (global_xtop + .5);
      left += (int) (global_xleft + .5);
      width = (int) (global_hsize + .5);
      height = (int) (global_vsize + .5);
      break;
    case SIZE_IN:
      top += (int) ((global_xtop * 72) + .5);
      left += (int) ((global_xleft * 72) + .5);
      width = (int) ((global_hsize * 72) + .5);
      height = (int) ((global_vsize * 72) + .5);
      break;
    case SIZE_MM:
      top += (int) ((global_xtop * 72 / 25.4) + .5);
      left += (int) ((global_xleft * 72 / 25.4) + .5);
      width = (int) ((global_hsize * 72 / 25.4) + .5);
      height = (int) ((global_vsize * 72 / 25.4) + .5);
      break;
    case SIZE_RELATIVE:
    default:
      top += height * global_xtop;
      left += width * global_xleft;
      width *= global_hsize;
      height *= global_vsize;
      break;
    }
  stp_set_width(v, width);
  stp_set_height(v, height);
#if 0
  width = (width / global_steps) * global_steps;
  height = (height / global_n_testpatterns) * global_n_testpatterns;
#endif
  if (global_steps > width)
    global_steps = width;

  global_printer_width = width * x / 72;
  global_printer_height = height * y / 72;

  global_band_height = global_printer_height / global_n_testpatterns;
  if (global_band_height == 0)
    global_band_height = 1;
  stp_set_left(v, left);
  stp_set_top(v, top);

  stp_merge_printvars(v, stp_printer_get_defaults(the_printer));
  if (stp_verify(v))
    {
      bytes_written = 0;
      if (start_job)
	{
	  stp_start_job(v, &theImage);
	  start_job = 0;
	}
      if (stp_print(v, &theImage) != 1)
	{
	  if (!global_quiet)
	    fputs("FAILED", stderr);
	  failures++;
	  status = 2;
	  if (global_halt_on_error)
	    return status;
	}
      else if (bytes_written == 0)
	{
	  if (!global_quiet)
	    fputs("FAILED: No output", stderr);
	  failures++;
	  status = 2;
	  if (global_halt_on_error)
	    return status;
	}
      else
	passes++;
      if (end_job)
	{
	  stp_end_job(v, &theImage);
	  end_job = 0;
	}
    }
  else
    {
      if (! global_fail_verify_ok)
	{
	  if (!global_quiet)
	    fputs("FAILED", stderr);
	  failures++;
	  status = 2;
	  if (global_halt_on_error)
	    return status;
	}
      else
	{
	  if (!global_quiet)
	    fputs("(skipped)", stderr);
	  skipped++;
	}
    }
  if (!global_quiet)
    fputc('\n', stderr);
  stp_vars_destroy(v);
  stp_free(static_testpatterns);
  static_testpatterns = NULL;
  return status;
}