Beispiel #1
0
 /**
  * Mathematical operation /
  * it divides the subpixels with the value 
  */
 Pixel<T> operator/=(const T &rhs) {
   for(unsigned char i = 0; i < size_; ++i) {
     pixel_[i] /= rhs;
     validate_value(pixel_[i]);
   }
   return *this;
 }
Beispiel #2
0
  /**
   * Mathematical operation /
   * if the size of the left hand side object is 0 the right hand side 
   * else the size of both pixels has to be the same
   */
  Pixel<T> operator/=(const Pixel<T> &rhs) {
    if(size_ == rhs.size()) {
      for(unsigned char i = 0; i < size_; ++i) {
        pixel_[i] /= rhs.get_pixel(i);
        validate_value(pixel_[i]);
      }
      return *this;
    } else if(size_ == 0) {
       size_ = rhs.size();
  
      delete[] pixel_; 
      
      T *temp = new T[size_];

      for(unsigned char i = 0; i < size_; ++i) {
        temp[i] = rhs.get_pixel(i);
      }

      
      pixel_ = temp;; 
      return *this;
    }
    std::ostringstream ss;
    ss << "A Division between pixels can only happen when they have the same "
    << "size!\t LHS: " << size_ << "\tRHS: "<< rhs.size() << '\n';

    throw std::range_error(ss.str());
  }
Beispiel #3
0
// called when cell has been edited
static void renderer_edited(GtkCellRendererText *cell,
			    const gchar *path_string,
			    const gchar *new_text, gpointer user_data)
{
	GtkWidget *tree = user_data;
	GtkTreeView *view = GTK_TREE_VIEW(tree);
	GtkTreeModel *model = gtk_tree_view_get_model(view);
	GtkTreeStore *store = GTK_TREE_STORE(model);

	GtkTreePath *path = gtk_tree_path_new_from_string(path_string);
	GtkTreeIter iter, child;
	
	IO_DEF *s;
	gchar *str;
	uint32_t value;
	gboolean valid;

	if (!gtk_tree_model_get_iter(model, &iter, path))
		return;
		
	gtk_tree_model_get(model, &iter, COL_VALUE, &str, COL_S, &s, -1);
	sscanf(str, "%x", &value);
	g_free(str);

	// change value in memory
	if(validate_value(new_text, 2 *s->size))
	{
		sscanf(new_text, "%x", &value);			

		switch(s->size)
		{
		case 1: mem_wr_byte(s->addr, (uint8_t )value); break;
		case 2: mem_wr_word(s->addr, (uint16_t)value); break;
		case 4: mem_wr_long(s->addr, (uint32_t)value); break;
		default: break;
		}
	}

	// and change displayed value (don't rely on typed value !)
	str = rd_mem_as_str(s);
	gtk_tree_store_set(store, &iter, COL_VALUE, str, -1);
	g_free(str);

	// update bits (children nodes)
	for(valid = gtk_tree_model_iter_children(model, &child, &iter);
        valid; 
        valid = gtk_tree_model_iter_next(model, &child))
    {
		gchar* bit_adr;
		int	   bit_num;

		gtk_tree_model_get(model, &child, COL_NAME, &str, COL_ADDR, &bit_adr, -1);
		sscanf(bit_adr, "%i", &bit_num);
		gtk_tree_store_set(store, &child, COL_BTNACT, rd_bit(s, bit_num), -1);
	}
	
	gtk_tree_path_free(path);
}
Beispiel #4
0
static int gt_obo_parse_tree_validate_stanzas(const GtOBOParseTree
                                              *obo_parse_tree,
                                              GtError *err)
{
  unsigned long i;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(obo_parse_tree);
  for (i = 0; !had_err && i < gt_obo_parse_tree_num_of_stanzas(obo_parse_tree);
       i++) {
    GtOBOStanza *stanza = *(GtOBOStanza**)
                          gt_array_get(obo_parse_tree->stanzas, i);
    if (!strcmp(gt_obo_parse_tree_get_stanza_type(obo_parse_tree, i), "Term")) {
      had_err = validate_value(stanza, "id", err);
      if (!had_err)
        had_err = validate_value(stanza, "name", err);
    }
    else if (!strcmp(gt_obo_parse_tree_get_stanza_type(obo_parse_tree, i),
                     "Typedef")) {
      had_err = validate_value(stanza, "id", err);
      if (!had_err)
        had_err = validate_value(stanza, "name", err);
    }
    else if (!strcmp(gt_obo_parse_tree_get_stanza_type(obo_parse_tree, i),
                                                    "Instance")) {
      had_err = validate_value(stanza, "id", err);
      if (!had_err)
        had_err = validate_value(stanza, "name", err);
      if (!had_err)
        had_err = validate_value(stanza, "instance_of", err);
    }
  }
  return had_err;
}
Beispiel #5
0
  /**
   * @return returns a reference to the calling object, the object has only one
   * subpixel that has the value of the average gray value
   */
  Pixel<T> &grey() {
    T *del = pixel_;
    pixel_ = new T[1]();
    
    for(unsigned char i = 0; i < size_; ++i) {
      pixel_[0] += del[i] / size_;
    }

    validate_value(pixel_[0]);

    delete[] del;
    size_ = 1;
    return *this;
  }
Beispiel #6
0
static void renderer_edited(GtkCellRendererText * cell,
			    const gchar * path_string,
			    const gchar * new_text, gpointer user_data)
{
    GtkWidget *tree = user_data;
	GtkTreeView *view = GTK_TREE_VIEW(tree);
	GtkTreeModel *model = gtk_tree_view_get_model(view);
	GtkTreeStore *store = GTK_TREE_STORE(model);

	GtkTreePath *path = gtk_tree_path_new_from_string(path_string);
	GtkTreeIter iter;
	
	uint32_t value;
	gint n;

	if (!gtk_tree_model_get_iter(model, &iter, path))
		return;
		
	if (strlen(path_string) < 3)
		return;
	
	// set new value	
	n = path_string[2] - '0';
	switch(path_string[0] - '0')
	{
		case 1:	// Ax
			if(validate_value(new_text, 8))
			{
				sscanf(new_text, "%x", &value);			
				gtk_tree_store_set(store, &iter, COL_VALUE, new_text,	-1);
				ti68k_register_set_addr(n, value);
				if((n == 6) || (n == 7))
					dbgstack_refresh_window();
			}
		break;
		case 0:	// Dx
			if(validate_value(new_text, 8))
			{
				sscanf(new_text, "%x", &value);			
				gtk_tree_store_set(store, &iter, COL_VALUE, new_text,	-1);
				ti68k_register_set_data(n, value);
			}
		break;
		case 2:	// Others
			switch(n)
			{
				case 0:	// pc
					if(validate_value(new_text, 6))
					{
						sscanf(new_text, "%x", &value);			
						gtk_tree_store_set(store, &iter, COL_VALUE, new_text,	-1);
						ti68k_register_set_pc(value);
					}
				break;		
				case 1:	// usp
					if(validate_value(new_text, 6))
					{
						sscanf(new_text, "%x", &value);			
						gtk_tree_store_set(store, &iter, COL_VALUE, new_text,	-1);
						ti68k_register_set_usp(value);
					}
				break;
                case 2:	// ssp
					if(validate_value(new_text, 6))
					{
						sscanf(new_text, "%x", &value);			
						gtk_tree_store_set(store, &iter, COL_VALUE, new_text,	-1);
						ti68k_register_set_ssp(value);
					}
				break;
				case 3: // sr
					if(validate_value(new_text, 4))
					{
						sscanf(new_text, "%x", &value);			
						gtk_tree_store_set(store, &iter, COL_VALUE, new_text,	-1);
						ti68k_register_set_sr(value);

                        // update usp <=> ssp
                        dbgregs_refresh_window();
                        dbgstack_refresh_window();
					}
				break;
				case 4: // super-flags
					if(ti68k_register_set_flags(new_text, NULL))
                    {
                        uint32_t data;
                        gchar *sdata;

						gtk_tree_store_set(store, &iter, COL_VALUE, new_text,	-1);
                        
                        // update sr, too
                        gtk_tree_path_free(path);	
                        path = gtk_tree_path_new_from_string("2:2");
                        if (!gtk_tree_model_get_iter(model, &iter, path))
		                    return;
                        ti68k_register_get_sr(&data);
                        sdata = g_strdup_printf("%04x", data);
                        gtk_tree_store_set(store, &iter, COL_VALUE, sdata,	-1);
                        g_free(sdata);
                        
                        // update usp <=> ssp
                        dbgregs_refresh_window();
                        dbgstack_refresh_window();
                    }
				case 5: // user-flags
					if(ti68k_register_set_flags(NULL, new_text))
                    {
                        uint32_t data;
                        gchar *sdata;

						gtk_tree_store_set(store, &iter, COL_VALUE, new_text,	-1);

                        // update sr, too
                        gtk_tree_path_free(path);	
                        path = gtk_tree_path_new_from_string("2:2");
                        if (!gtk_tree_model_get_iter(model, &iter, path))
		                    return;
                        ti68k_register_get_sr(&data);
                        sdata = g_strdup_printf("%04x", data);
                        gtk_tree_store_set(store, &iter, COL_VALUE, sdata,	-1);
                        g_free(sdata);
                    }
					break;
				break;
			}
		break;
		default:
		break;
	}

	gtk_tree_path_free(path);
}
Beispiel #7
0
static int validate_tag(tag_t *tag)
{
	int start_len, end_len;
	char *str;
	char start_name[128];
	char end_name[128];
	//int i,j;
	//char *ch,*ch1;

	//fprintf(stderr,"\r\nInside validate_tag with tag->start_len:%d & tag->start_name\n",tag->start_len);
	//ch = tag->start_name;
	//for (i=0;i<tag->start_len;i++ )
	//{
	// fprintf(stderr,"%c",*ch++);
	//}

	start_len = tag->start_len-2; // ignore open and closing braces

	if(tag->attr_len) // ignore space + attributes
		start_len = start_len - (tag->attr_len+1);
	strncpy(start_name, tag->start_name + 1, start_len);
	start_name[start_len] = 0x00;
	/* start tag must be valid here */
	if(validate_start_tag(tag->start_name, tag->start_len))
		return -1;

	//fprintf(stderr,"\r\nInside validate_tag with tag->end_len:%d & tag->end_name\n",tag->end_len);
	//ch1 = tag->end_name;
	//for (j=0;j<tag->end_len;j++ )
	//{
	//  fprintf(stderr,"%c",*ch1++);
	//}

	if(!tag->empty) {
		end_len = tag->end_len-3; // ignore braces and /
		strncpy(end_name, tag->end_name+2, end_len);
		end_name[end_len] = 0x00;

		if(tag->end_name[1] != '/') {
			if(tag->value_len == 0)
				return 1;	/* no match, treat as a child */
			return -6;		/* value with no end tag is incorrect */
		}
		if(strcmp(start_name, end_name))
			return -5;   /* start an end tag don't match */
	}

	if(validate_attributes(tag->attr_name, tag->attr_len))
		return -2;

	if(validate_value(tag->value_name, tag->value_len))
		return -3;

	if(validate_end_tag(tag->end_name, tag->end_len))
		return -4;

	if(start_len) {
		str = malloc(start_len+1);
		if(!str) return -5;
		memcpy(str, start_name, start_len);
		str[start_len] = 0x00;
		tag->name = str;
	}

	if(tag->value_len) {
		str = malloc(tag->value_len+1);
		if(!str) return -6;
		memcpy(str, tag->value_name, tag->value_len);
		str[tag->value_len] = 0x00;
		tag->value = str;
	}

	if(tag->attr_len) {
		str = malloc(tag->attr_len+1);
		if(!str) return -7;
		memcpy(str, tag->attr_name, tag->attr_len);
		str[tag->attr_len] = 0x00;
		tag->attr = str;
	}

	return 0;  /* match */
}
layer *read_mouse_layer(xmlDocPtr document, xmlNodePtr this_node)
{
	// Local variables
	GString				*message;					// Used to construct message strings
	layer				*tmp_layer;					// Temporary layer
	layer_mouse			*tmp_mouse_ob;				// Temporary mouse layer object
	xmlChar				*tmp_xmlChar;				// Temporary xmlChar pointer
	gboolean			usable_input = TRUE;		// Used as a flag to indicate if all validation was successful
	gfloat				*validated_gfloat;			// Receives known good gfloat values from the validation function
	guint				*validated_guint;			// Receives known good guint values from the validation function
	GString				*validated_string;			// Receives known good strings from the validation function


	// Initialisation
	message = g_string_new(NULL);

	// Construct a new mouse pointer layer
	tmp_mouse_ob = g_new0(layer_mouse, 1);
	tmp_layer = g_new0(layer, 1);
	tmp_layer->object_type = TYPE_MOUSE_CURSOR;
	tmp_layer->object_data = (GObject *) tmp_mouse_ob;
	tmp_layer->external_link = g_string_new(NULL);
	tmp_layer->visible = TRUE;
	tmp_layer->background = FALSE;
	tmp_layer->external_link_window = g_string_new("_self");
	tmp_layer->start_time = 0.0;
	tmp_layer->transition_in_type = TRANS_LAYER_NONE;
	tmp_layer->transition_in_duration = 0.0;
	tmp_layer->duration = get_default_layer_duration();
	tmp_layer->transition_out_type = TRANS_LAYER_NONE;
	tmp_layer->transition_out_duration = 0.0;

	// Load the highlight layer values
	while (NULL != this_node)
	{
		if ((!xmlStrcmp(this_node->name, (const xmlChar *) "x_offset_start")))
		{
			// Get the starting x offset
			tmp_xmlChar = xmlNodeListGetString(document, this_node->xmlChildrenNode, 1);
			validated_guint = validate_value(X_OFFSET, V_CHAR, tmp_xmlChar);
			xmlFree(tmp_xmlChar);
			if (NULL == validated_guint)
			{
				g_string_printf(message, "%s ED248: %s", _("Error"), _("There was something wrong with an x offset start value in the project file."));
				display_warning(message->str);
				usable_input = FALSE;
				tmp_layer->x_offset_start = 0;  // Fill in the value, just to be safe
			} else
			{
				tmp_layer->x_offset_start = *validated_guint;
				g_free(validated_guint);
			}
		}
		if ((!xmlStrcmp(this_node->name, (const xmlChar *) "y_offset_start")))
		{
			// Get the starting y offset
			tmp_xmlChar = xmlNodeListGetString(document, this_node->xmlChildrenNode, 1);
			validated_guint = validate_value(Y_OFFSET, V_CHAR, tmp_xmlChar);
			xmlFree(tmp_xmlChar);
			if (NULL == validated_guint)
			{
				g_string_printf(message, "%s ED249: %s", _("Error"), _("There was something wrong with a y offset start value in the project file."));
				display_warning(message->str);
				usable_input = FALSE;
				tmp_layer->y_offset_start = 0;  // Fill in the value, just to be safe
			} else
			{
				tmp_layer->y_offset_start = *validated_guint;
				g_free(validated_guint);
			}
		}
		if ((!xmlStrcmp(this_node->name, (const xmlChar *) "x_offset_finish")))
		{
			// Get the finishing x offset
			tmp_xmlChar = xmlNodeListGetString(document, this_node->xmlChildrenNode, 1);
			validated_guint = validate_value(X_OFFSET, V_CHAR, tmp_xmlChar);
			xmlFree(tmp_xmlChar);
			if (NULL == validated_guint)
			{
				g_string_printf(message, "%s ED250: %s", _("Error"), _("There was something wrong with an x offset finish value in the project file."));
				display_warning(message->str);
				usable_input = FALSE;
				tmp_layer->x_offset_finish = 0;  // Fill in the value, just to be safe
			} else
			{
				tmp_layer->x_offset_finish = *validated_guint;
				g_free(validated_guint);
			}
		}
		if ((!xmlStrcmp(this_node->name, (const xmlChar *) "y_offset_finish")))
		{
			// Get the finishing y offset
			tmp_xmlChar = xmlNodeListGetString(document, this_node->xmlChildrenNode, 1);
			validated_guint = validate_value(Y_OFFSET, V_CHAR, tmp_xmlChar);
			xmlFree(tmp_xmlChar);
			if (NULL == validated_guint)
			{
				g_string_printf(message, "%s ED251: %s", _("Error"), _("There was something wrong with a y offset finish value in the project file."));
				display_warning(message->str);
				usable_input = FALSE;
				tmp_layer->y_offset_finish = 0;  // Fill in the value, just to be safe
			} else
			{
				tmp_layer->y_offset_finish = *validated_guint;
				g_free(validated_guint);
			}
		}
		if ((!xmlStrcmp(this_node->name, (const xmlChar *) "width")))
		{
			// Get the width
			tmp_xmlChar = xmlNodeListGetString(document, this_node->xmlChildrenNode, 1);
			validated_guint = validate_value(LAYER_WIDTH, V_CHAR, tmp_xmlChar);
			xmlFree(tmp_xmlChar);
			if (NULL == validated_guint)
			{
				g_string_printf(message, "%s ED252: %s", _("Error"), _("There was something wrong with a layer width value in the project file."));
				display_warning(message->str);
				usable_input = FALSE;
				tmp_mouse_ob->width = 1;  // Fill in the value, just to be safe
			} else
			{
				tmp_mouse_ob->width = *validated_guint;
				g_free(validated_guint);
			}
		}
		if ((!xmlStrcmp(this_node->name, (const xmlChar *) "height")))
		{
			// Get the height
			tmp_xmlChar = xmlNodeListGetString(document, this_node->xmlChildrenNode, 1);
			validated_guint = validate_value(LAYER_HEIGHT, V_CHAR, tmp_xmlChar);
			xmlFree(tmp_xmlChar);
			if (NULL == validated_guint)
			{
				g_string_printf(message, "%s ED253: %s", _("Error"), _("There was something wrong with a layer height value in the project file."));
				display_warning(message->str);
				usable_input = FALSE;
				tmp_mouse_ob->height = 1;  // Fill in the value, just to be safe
			} else
			{
				tmp_mouse_ob->height = *validated_guint;
				g_free(validated_guint);
			}
		}
		if ((!xmlStrcmp(this_node->name, (const xmlChar *) "click")))
		{
			// Get the mouse click type
			tmp_xmlChar = xmlNodeListGetString(document, this_node->xmlChildrenNode, 1);
			validated_string = validate_value(MOUSE_CLICK, V_CHAR, tmp_xmlChar);
			xmlFree(tmp_xmlChar);
			if (NULL == validated_string)
			{
				g_string_printf(message, "%s ED254: %s", _("Error"), _("There was something wrong with a mouse click value in the project file."));
				display_warning(message->str);
				usable_input = FALSE;
				tmp_mouse_ob->click = MOUSE_NONE;  // Fill in the value, just to be safe
			} else
			{
				tmp_mouse_ob->click = MOUSE_NONE;  // Set the default
				if (0 == g_ascii_strncasecmp(validated_string->str, "left_one", 8))
					tmp_mouse_ob->click = MOUSE_LEFT_ONE;
				if (0 == g_ascii_strncasecmp(validated_string->str, "left_double", 11))
					tmp_mouse_ob->click = MOUSE_LEFT_DOUBLE;
				if (0 == g_ascii_strncasecmp(validated_string->str, "left_triple", 11))
					tmp_mouse_ob->click = MOUSE_LEFT_TRIPLE;
				if (0 == g_ascii_strncasecmp(validated_string->str, "right_one", 9))
					tmp_mouse_ob->click = MOUSE_RIGHT_ONE;
				if (0 == g_ascii_strncasecmp(validated_string->str, "right_double", 12))
					tmp_mouse_ob->click = MOUSE_RIGHT_DOUBLE;
				if (0 == g_ascii_strncasecmp(validated_string->str, "right_triple", 12))
					tmp_mouse_ob->click = MOUSE_RIGHT_TRIPLE;
				if (0 == g_ascii_strncasecmp(validated_string->str, "middle_one", 10))
					tmp_mouse_ob->click = MOUSE_MIDDLE_ONE;
				if (0 == g_ascii_strncasecmp(validated_string->str, "middle_double", 13))
					tmp_mouse_ob->click = MOUSE_MIDDLE_DOUBLE;
				if (0 == g_ascii_strncasecmp(validated_string->str, "middle_triple", 13))
					tmp_mouse_ob->click = MOUSE_MIDDLE_TRIPLE;
				g_string_free(validated_string, TRUE);
				validated_string = NULL;
			}
		}
		if ((!xmlStrcmp(this_node->name, (const xmlChar *) "start_time")))
		{
			// Get the start time
			tmp_xmlChar = xmlNodeListGetString(document, this_node->xmlChildrenNode, 1);
			validated_gfloat = validate_value(LAYER_DURATION, V_CHAR, tmp_xmlChar);
			xmlFree(tmp_xmlChar);
			if (NULL == validated_gfloat)
			{
				g_string_printf(message, "%s ED344: %s", _("Error"), _("There was something wrong with a layer start time value in the project file."));
				display_warning(message->str);
				usable_input = FALSE;
				tmp_layer->start_time = 0;  // Fill in the value, just to be safe
			} else
			{
				tmp_layer->start_time = *validated_gfloat;
				g_free(validated_gfloat);
			}
		}
		if ((!xmlStrcmp(this_node->name, (const xmlChar *) "duration")))
		{
			// Get the finish frame
			tmp_xmlChar = xmlNodeListGetString(document, this_node->xmlChildrenNode, 1);
			validated_gfloat = validate_value(LAYER_DURATION, V_CHAR, tmp_xmlChar);
			xmlFree(tmp_xmlChar);
			if (NULL == validated_gfloat)
			{
				g_string_printf(message, "%s ED345: %s", _("Error"), _("There was something wrong with a layer duration value in the project file."));
				display_warning(message->str);
				usable_input = FALSE;
				tmp_layer->duration = 0;  // Fill in the value, just to be safe
			} else
			{
				tmp_layer->duration = *validated_gfloat;
				g_free(validated_gfloat);
			}
		}
		if ((!xmlStrcmp(this_node->name, (const xmlChar *) "visible")))
		{
			// Get the visibility
			tmp_xmlChar = xmlNodeListGetString(document, this_node->xmlChildrenNode, 1);
			validated_guint = validate_value(LAYER_VISIBLE, V_CHAR, tmp_xmlChar);
			xmlFree(tmp_xmlChar);
			if (NULL == validated_guint)
			{
				g_string_printf(message, "%s ED257: %s", _("Error"), _("There was something wrong with a layer visibility value in the project file."));
				display_warning(message->str);
				usable_input = FALSE;
				tmp_layer->visible = 0;  // Fill in the value, just to be safe
			} else
			{
				tmp_layer->visible = *validated_guint;
				g_free(validated_guint);
			}
		}
		if ((!xmlStrcmp(this_node->name, (const xmlChar *) "name")))
		{
			// Get the name of the layer
			tmp_xmlChar = xmlNodeListGetString(document, this_node->xmlChildrenNode, 1);
			validated_string = validate_value(LAYER_NAME, V_CHAR, tmp_xmlChar);
			xmlFree(tmp_xmlChar);
			if (NULL == validated_string)
			{
				g_string_printf(message, "%s ED258: %s", _("Error"), _("There was something wrong with a layer name value in the project file."));
				display_warning(message->str);
				usable_input = FALSE;
				tmp_layer->name = g_string_new("Empty");  // Fill in the value, just to be safe
			} else
			{
				tmp_layer->name = validated_string;  // We keep the validated string instead of copying then freeing it
				validated_string = NULL;
			}
		}
		if ((!xmlStrcmp(this_node->name, (const xmlChar *) "external_link")))
		{
			// Get the URL associated with the layer
			tmp_xmlChar = xmlNodeListGetString(document, this_node->xmlChildrenNode, 1);
			validated_string = validate_value(EXTERNAL_LINK, V_CHAR, tmp_xmlChar);
			xmlFree(tmp_xmlChar);
			if (NULL == validated_string)
			{
				g_string_printf(message, "%s ED259: %s", _("Error"), _("There was something wrong with an external link value in the project file."));
				display_warning(message->str);
				usable_input = FALSE;
			} else
			{
				tmp_layer->external_link = g_string_assign(tmp_layer->external_link, validated_string->str);
				g_string_free(validated_string,TRUE);
				validated_string = NULL;
			}
		}
		if ((!xmlStrcmp(this_node->name, (const xmlChar *) "external_link_window")))
		{
			// Get the window to open the URL associated with the layer
			tmp_xmlChar = xmlNodeListGetString(document, this_node->xmlChildrenNode, 1);
			validated_string = validate_value(EXTERNAL_LINK_WINDOW, V_CHAR, tmp_xmlChar);
			xmlFree(tmp_xmlChar);
			if (NULL == validated_string)
			{
				g_string_printf(message, "%s ED260: %s", _("Error"), _("There was something wrong with an external link target window value in the project file."));
				display_warning(message->str);
				usable_input = FALSE;
			} else
			{
				tmp_layer->external_link_window = g_string_assign(tmp_layer->external_link_window, validated_string->str);
				g_string_free(validated_string,TRUE);
				validated_string = NULL;
			}
		}
		if ((!xmlStrcmp(this_node->name, (const xmlChar *) "transition_in_type")))
		{
			// Get the type of transition in
			tmp_xmlChar = xmlNodeListGetString(document, this_node->xmlChildrenNode, 1);
			validated_string = validate_value(TRANSITION_TYPE, V_CHAR, tmp_xmlChar);
			xmlFree(tmp_xmlChar);
			if (NULL == validated_string)
			{
				g_string_printf(message, "%s ED321: %s", _("Error"), _("There was something wrong with a transition in type value in the project file."));
				display_warning(message->str);
				usable_input = FALSE;
			} else
			{
				if (0 == g_ascii_strncasecmp(validated_string->str, "fade", 4))
				{
					tmp_layer->transition_in_type = TRANS_LAYER_FADE;
				} else
				{
					tmp_layer->transition_in_type = TRANS_LAYER_NONE;
				}
				g_string_free(validated_string, TRUE);
				validated_string = NULL;
			}
		}
		if ((!xmlStrcmp(this_node->name, (const xmlChar *) "transition_in_duration")))
		{
			// Get the transition in duration
			tmp_xmlChar = xmlNodeListGetString(document, this_node->xmlChildrenNode, 1);
			validated_gfloat = validate_value(TRANSITION_DURATION, V_CHAR, tmp_xmlChar);
			xmlFree(tmp_xmlChar);
			if (NULL == validated_gfloat)
			{
				g_string_printf(message, "%s ED322: %s", _("Error"), _("There was something wrong with a transition in duration value in the project file."));
				display_warning(message->str);
				usable_input = FALSE;
				tmp_layer->transition_in_duration = 1;  // Fill in the value, just to be safe
			} else
			{
				tmp_layer->transition_in_duration = *validated_gfloat;
				g_free(validated_gfloat);
			}
		}
		if ((!xmlStrcmp(this_node->name, (const xmlChar *) "transition_out_type")))
		{
			// Get the type of transition out
			tmp_xmlChar = xmlNodeListGetString(document, this_node->xmlChildrenNode, 1);
			validated_string = validate_value(TRANSITION_TYPE, V_CHAR, tmp_xmlChar);
			xmlFree(tmp_xmlChar);
			if (NULL == validated_string)
			{
				g_string_printf(message, "%s ED323: %s", _("Error"), _("There was something wrong with a transition out type value in the project file."));
				display_warning(message->str);
				usable_input = FALSE;
			} else
			{
				if (0 == g_ascii_strncasecmp(validated_string->str, "fade", 4))
				{
					tmp_layer->transition_out_type = TRANS_LAYER_FADE;
				} else
				{
					tmp_layer->transition_out_type = TRANS_LAYER_NONE;
				}
				g_string_free(validated_string, TRUE);
				validated_string = NULL;
			}
		}
		if ((!xmlStrcmp(this_node->name, (const xmlChar *) "transition_out_duration")))
		{
			// Get the transition out duration
			tmp_xmlChar = xmlNodeListGetString(document, this_node->xmlChildrenNode, 1);
			validated_gfloat = validate_value(TRANSITION_DURATION, V_CHAR, tmp_xmlChar);
			xmlFree(tmp_xmlChar);
			if (NULL == validated_gfloat)
			{
				g_string_printf(message, "%s ED324: %s", _("Error"), _("There was something wrong with a transition out duration value in the project file."));
				display_warning(message->str);
				usable_input = FALSE;
				tmp_layer->transition_out_duration = 1;  // Fill in the value, just to be safe
			} else
			{
				tmp_layer->transition_out_duration = *validated_gfloat;
				g_free(validated_gfloat);
			}
		}
		this_node = this_node->next;
	}

	// Free memory allocated in this function
	g_string_free(message, TRUE);

	// Return the validated mouse layer, or an indicator of failure
	if (TRUE == usable_input)
	{
		return tmp_layer;
	} else
	{
		// Free the newly allocated mouse layer data, as it didn't pass validation, so we won't use it
		layer_free(tmp_layer);
		return NULL;
	}
}
Beispiel #9
0
bool
he_value_page_c::validate_this() {
  if (!m_input->IsEnabled())
    return true;
  return validate_value();
}