Example #1
0
void rectangle_set_border_color_html(rectangle_t * const obj, const char* html_color_code)
{
	PTR_CHECK(obj, "rectangle");

	obj->border_color = color_html(html_color_code);
	obj->has_border = true;
}
Example #2
0
void rectangle_set_border_tickness(rectangle_t * const obj, dim_t tickness)
{
	PTR_CHECK(obj, "rectangle");

	obj->border_tickness = tickness;
	obj->has_border = true;
}
Example #3
0
void rectangle_set_fill_color_html(rectangle_t * const obj, const char *html_color_code)
{
	PTR_CHECK(obj, "rectangle");

	obj->fill_color = color_html(html_color_code);
	obj->is_filled = true;
}
Example #4
0
void signal2_delete(signal2_t * obj)
{
	PTR_CHECK(obj, "signal2");

	stack_delete(obj->slot2s_stack);

	free(obj);
}
Example #5
0
void rectangle_delete(rectangle_t * const obj)
{
	PTR_CHECK(obj, "rectangle");

	my_log_delete(obj->log);
	widget_delete_instance_only(obj->glyph);

	free(obj);
}
Example #6
0
static void signal2_connect(signal2_t *obj, slot2_t *slot2)
{
	PTR_CHECK(obj, "signal2");

	if (signal2_is_connected(obj, slot2))
		return;

	stack_add(obj->slot2s_stack, (BUFFER_PTR)&slot2);
}
Example #7
0
void ring_fifo_zerocopy_push_finish(ring_fifo_t * cobj)
{
	struct s_ring_fifo_private * obj = (struct s_ring_fifo_private *)cobj;
	PTR_CHECK(obj, "ring_fifo");

	if (!obj->nocp_push_started)
		return;

	obj->wr++;
	obj->nocp_push_started = false;
}
Example #8
0
void my_string_delete(my_string_t *obj)
{
	PTR_CHECK(obj, "my_string");

	if (obj->str_data)
		free(obj->str_data);

	signal_delete(obj->update_signal);

	free(obj);
}
Example #9
0
void slot2_set(slot2_t *obj, slot2_func function, slot_arg arg)
{
	PTR_CHECK(obj, "slot2");

	if (!function) {
		LOG_ERROR("slot2", "bad slot2 function");
		return;
	}

	obj->func = function;
	obj->arg0 = arg;
	obj->set = true;
}
Example #10
0
void ring_fifo_deinit(ring_fifo_t *cobj)
{
	struct s_ring_fifo_private * obj = (struct s_ring_fifo_private *)cobj;
	PTR_CHECK(obj, "ring_fifo");

	obj->buffer = NULL;
	obj->client_buffer = NULL;

#ifdef CHELPER_ALLOW_MALLOC
	if (obj->own_buffer) {
		free (obj->own_buffer);
		obj->own_buffer = NULL;
	}
#endif
}
Example #11
0
void signal2_emit(signal2_t *obj, size_t x, size_t y)
{
	uint32_t n_of_slot2s;
	slot2_t *slot2_to_be_called = NULL;

	PTR_CHECK(obj, "signal2");

	n_of_slot2s = stack_size(obj->slot2s_stack);

	while(n_of_slot2s--)
	{
		stack_get(obj->slot2s_stack, (BUFFER_PTR)&slot2_to_be_called, n_of_slot2s);
		slot2_call(slot2_to_be_called, x, y);
	}

}
Example #12
0
static void slot2_call(slot2_t *obj, size_t x, size_t y)
{
	PTR_CHECK(obj, "slot2");

	if (!obj->set) {
		LOG_ERROR("slot2", "no slot2 function set");
		return;
	}

	if (!obj->func) {
		LOG_ERROR("slot2", "bad slot2 function");
		return;
	}

	obj->func(obj->arg0, x, y);
}
Example #13
0
void ring_fifo_init(ring_fifo_t * cobj, size_t element_size, int32_t num_of_elements)
{
	struct s_ring_fifo_private * obj = (struct s_ring_fifo_private *)cobj;
	PTR_CHECK(obj, "ring_fifo");

	obj->own_buffer = (BUFFER_PTR)malloc(element_size * num_of_elements);
	obj->num_fifo_slots = num_of_elements;
	obj->client_buffer = NULL;
	obj->buffer = obj->own_buffer;
	obj->element_size = element_size;
	obj->rd = 0;
	obj->wr = 0;
	obj->nocp_pop_started = false;
	obj->nocp_push_started = false;

}
Example #14
0
void ring_fifo_init_buffer(ring_fifo_t * cobj, BUFFER_PTR buffer, size_t buffer_size, size_t element_size)
{
	size_t num_of_elements;
	struct s_ring_fifo_private * obj = (struct s_ring_fifo_private *)cobj;
	PTR_CHECK(obj, "ring_fifo");

	num_of_elements = buffer_size / element_size;

	obj->num_fifo_slots = num_of_elements;

	obj->own_buffer = NULL;
	obj->client_buffer = buffer;
	obj->buffer = obj->client_buffer;
	obj->element_size = element_size;
	obj->rd = 0;
	obj->wr = 0;
	obj->nocp_pop_started = false;
	obj->nocp_push_started = false;
}
Example #15
0
static void draw(rectangle_t * obj, const area_t * limiting_canvas_area)
{
	dim_t least_dim;;

	PTR_CHECK(obj, "rectangle");

	if (!ready_to_draw(obj))
	{
		my_log(ERROR, __FILE__, __LINE__, "Object not initialized properly, can't draw.", obj->log);
		return;
	}

	if (bad_corner_radius(obj))
	{
		my_log(WARNING, __FILE__, __LINE__, "Bad corner radius. Radius has been reduced.", obj->log);
		least_dim  = get_smaller( widget_area(obj->glyph)->width,
							widget_area(obj->glyph)->height);
		obj->corner_radius = least_dim / 2;
	}

	decode_and_draw(obj, limiting_canvas_area);
}
Example #16
0
void slot2_delete(slot2_t * obj)
{
	PTR_CHECK(obj, "slot2");
	free(obj);
}
Example #17
0
void slot2_connect(slot2_t *obj, signal2_t* signal2)
{
	PTR_CHECK(obj, "slot2");

	signal2_connect(signal2, obj);
}
Example #18
0
void my_string_clear(my_string_t * obj)
{
	PTR_CHECK(obj, "my_string");

	_clear(obj);
}
Example #19
0
void rectangle_set_size(rectangle_t * const obj, dim_t width, dim_t height)
{
	PTR_CHECK(obj, "rectangle");

	widget_set_dim(obj->glyph, width, height);
}
Example #20
0
#include "core/var.h"
#include "core/signal.h"

std::string points_move_ops_test_str_1 =
R"({ "content" : [ )"
	R"({ "type" : "start_of_line", "name" : "A" }, )"
	R"({ "type" : "points", "name" : "P1" }, )"
	R"({ "type" : "end_of_line", "name" : "B" }, )"
	R"({ "type" : "end_of_line", "name" : "C", "connect" : { "to" : "P1" } } )"
"] }";

TEST_CASE( "track/ops/points/movement", "Test basic points movement future" ) {
	test_fixture_world_init_checked env(points_move_ops_test_str_1);
	points *p1;
	auto setup = [&]() {
		p1 = PTR_CHECK(env.w->FindTrackByNameCast<points>("P1"));
	};

	auto test = [&](std::function<void()> RoundTrip) {
		env.w->SubmitAction(action_points_action(*(env.w), *p1, 0, generic_points::PTF::REV, generic_points::PTF::REV));

		RoundTrip();
		REQUIRE(p1->GetPointsFlags(0) == generic_points::PTF::ZERO);
		env.w->GameStep(500);
		RoundTrip();
		REQUIRE(p1->GetPointsFlags(0) == (generic_points::PTF::REV | generic_points::PTF::OOC));
		env.w->GameStep(4500);
		RoundTrip();
		REQUIRE(p1->GetPointsFlags(0) == generic_points::PTF::REV);

		env.w->SubmitAction(action_points_action(*(env.w), *p1, 0, generic_points::PTF::LOCKED, generic_points::PTF::LOCKED));
Example #21
0
// Vyber retezce : zpracovani  [ num/id/() :  num/id/() ] EOL
// String / id je j*z nacteny
int expr_string(T_Var **num1 , T_Var **num2)
{
// [ -------cekam cislo nebo :
   lex_rc = GetToken(&token);
   TOKEN_CHECK;

   if ((lex_rc == NID_NUMBER) || (lex_rc == TOKEN_IDENTIFICATOR)) {
      //1. NUMBER
      if (lex_rc == NID_NUMBER) {
         *num1 = malloc(sizeof(T_Var));
         PTR_CHECK(*num1);
         CDoubleToT_Var(atof(token.data), *num1);
         if (debug)printf("%f" , (*num1)->vals.d_val);
      }

      //2. IDENTIFIKATOR
      if (lex_rc == TOKEN_IDENTIFICATOR) {
         if (T_HTableExport(id_table, token.data, num1) == HASH_NOT_FOUND) {
            if (errno == 0) errno = SYNTACTIC_ERROR;
            if (debug)printf("non exist id");
            return EXIT_FAILURE;
         }
      }

      //------------------------------------------------------------------
      //COMA PO CISLE NEBO ID
      lex_rc = GetToken(&token);
      TOKEN_CHECK;
      if (debug) printf("-----%s----", token.data);
      if (lex_rc != TOKEN_COLUMN) {
         if (errno == 0) errno = SYNTACTIC_ERROR;
         if (debug)printf("cekam colum1");
         return EXIT_FAILURE;
      }
   }

   //colum PO HRANATE ZAVORCE
   else if (lex_rc == TOKEN_COLUMN) { *num1 = NULL; if (debug) printf("prazdno"); }
   else {
      if (errno == 0) errno = SYNTACTIC_ERROR;
      if (debug) printf("cekam colum2");
      return EXIT_FAILURE;
   }
//------------------------------------------------------------------
   lex_rc = GetToken(&token);
   TOKEN_CHECK;
   if ((lex_rc == NID_NUMBER) || (lex_rc == TOKEN_IDENTIFICATOR)) {
      //1. NUMBER 2
      if (lex_rc == NID_NUMBER) {
         *num2 = malloc(sizeof(T_Var));
         PTR_CHECK(*num2);
         CDoubleToT_Var(atof(token.data), *num2);
         if (debug) printf("%f" , (*num2)->vals.d_val);
      }
     //2. IDENTIFIKATOR 2
      if (lex_rc == TOKEN_IDENTIFICATOR) {
         if (T_HTableExport(id_table, token.data, &(*num2)) == HASH_NOT_FOUND) {
            if (errno == 0) errno = SYNTACTIC_ERROR;
            if (debug) printf("non exist id");
            return EXIT_FAILURE;}
     }
     // hranata po cisle nebo id
      lex_rc = GetToken(&token);
      TOKEN_CHECK;
      if (lex_rc != TOKEN_RSBRACKET) {
         if (errno == 0) errno = SYNTACTIC_ERROR;
         if (debug) printf("cekam hranata");
         return EXIT_FAILURE;
      }
   }
   else if (lex_rc == TOKEN_RSBRACKET) {*num2 = NULL; if (debug) printf("prazdno2");}
      else {
         if (errno == 0) errno = SYNTACTIC_ERROR;
         if (debug) printf("cekam hranata");
         return EXIT_FAILURE;
      }

   lex_rc=GetToken(&token);

   if ((lex_rc == TOKEN_EOL) || (lex_rc == TOKEN_EOF)) if (debug) printf(" %d ", lex_rc);
   else {
     if (errno == 0) errno = SYNTACTIC_ERROR;
     if (debug) printf("neni EOL");
     return EXIT_FAILURE;
   }
   return EXIT_SUCCESS;
}
Example #22
0
int stat(int mode)
{
   DEBUG_STAT;
   if (lex_rc == TOKEN_EOL)
      return EXIT_SUCCESS;

   if (lex_rc == TOKEN_IDENTIFICATOR) {
      if (T_HTableSearch(kw_table, token.data) != NULL) { // Keyword
         DEBUG_STAT_KEYWORD;
         return keyword(mode);
      }

      if (T_HTableSearch(builtin_table, token.data) != NULL)
         return CallBuiltin();

      int htable_rc = T_HTableExport(id_table, token.data, &write_var);
      if (htable_rc == HASH_FOUND && write_var->NID == NID_FUNCTION) { // Known function
         DEBUG_STAT_FUNCTION;
         CALL_CHECK(CallFunction());
         DEBUG_STAT_END;
         return EXIT_SUCCESS;
      }
      else { // Variable
         DEBUG_STAT_VAR;
         if (htable_rc == HASH_NOT_FOUND) {
            // Variable doesn't exist, create it as undefined and save into table
            T_Var *tmp_var = malloc(sizeof(T_Var));
            PTR_CHECK(tmp_var);

            T_VarInit(tmp_var);

            if (T_HTableInsert(id_table, token.data, tmp_var) == EXIT_FAILURE) {
               free(tmp_var);
               return EXIT_FAILURE;
            }
            free(tmp_var);
         }

         // Assign write_var pointer to newly created variable
         if (T_HTableExport(id_table, token.data, &write_var) == HASH_NOT_FOUND) {
            errno = INTERNAL_ERROR;
            return EXIT_FAILURE;
         }

         // Next expected token is assignment character
         lex_rc = GetToken(&token);
         TOKEN_CHECK;
         if (lex_rc == TOKEN_ASSIGN) {
            CALL_CHECK(expr());

            // write_var points to variable from the table, read_var points to the expression result
            GenerateInstruction(IID_COPY, write_var, read_var, NULL);

            DEBUG_STAT_END;
            return EXIT_SUCCESS;
         }
      }
   }

   errno = SYNTACTIC_ERROR;
   return EXIT_FAILURE;
}
Example #23
0
int CallFunction()
{
   // Saves a name of called function, currently located in token
   T_String f_name;
   T_StringInit(&f_name);
   T_StringCopy(&f_name, &token);

   // Opening bracket must follow
   lex_rc = GetToken(&token);
   TOKEN_CHECK;
   if (lex_rc == TOKEN_LBRACKET) {
      T_HashTable *tmp_table = malloc(sizeof(T_HashTable));
      T_Var *f_var = malloc(sizeof(T_Var));

      if (tmp_table == NULL || f_var == NULL) {
         free(tmp_table);
         free(f_var);
         errno = INTERNAL_ERROR;
         return EXIT_FAILURE;
      }

      T_HTableInit(tmp_table);
      T_VarInit(f_var);

      // Adds current id_table to table list and change its pointer
      T_IdListAppend(table_list, id_table);
      id_table = tmp_table;

      T_Var *var = malloc(sizeof(T_Var));
      PTR_CHECK(var);

      T_VarInit(var);
      var->NID = NID_CONST;

      char *reserved[] = {"as", "def", "directive", "export", "from", "import", "launch", "load", "macro", "input", "print", "numeric", "typeOf", "len", ""};

      T_HTableInit(id_table);

      for (int i = 0; strcmp(reserved[i], "") != 0; i++)
         T_HTableInsert(id_table, reserved[i], var);

      free(var);

      // Gets all function parameters into hash table
      if (write_var->vals.args.size > 0) {
         lex_rc = GetToken(&token);
         TOKEN_CHECK;
         CALL_CHECK(item());
         CALL_CHECK(T_HTableInsert(id_table, write_var->vals.args.first->data.data, read_var));
         CALL_CHECK(it_list(write_var->vals.args.first->next));
      }
      else {
         lex_rc = GetToken(&token);
         TOKEN_CHECK;
         if (lex_rc != TOKEN_RBRACKET) {
            errno = SYNTACTIC_ERROR;
            return EXIT_FAILURE;
         }
      }

      // Calls the function with the saved name
      T_StringToT_Var(&f_name, f_var);
      GenerateInstruction(IID_JUMP, f_var, NULL, NULL);

      // Generates a lable as a return point
      GenerateVariable(TRUE, &write_var);
      GenerateInstruction(IID_LABEL, write_var, NULL, NULL);
      T_LabelListAppend(cal_list, inst_list->last);

      free(f_var);

      return EXIT_SUCCESS;
   }

   errno = SYNTACTIC_ERROR;
   return EXIT_FAILURE;
}
Example #24
0
void rectangle_set_rounded_corner_radius(rectangle_t * const obj, dim_t radius)
{
	PTR_CHECK(obj, "rectangle");

	obj->corner_radius = radius;
}
Example #25
0
void rectangle_set_position(rectangle_t * const obj, dim_t x, dim_t y)
{
	PTR_CHECK(obj, "rectangle");

	widget_set_pos(obj->glyph, x, y);
}