Ejemplo n.º 1
0
Window* create_window_int(Rect frame, bool root) {
	Window* window = (Window*)kmalloc(sizeof(Window));
	memset(window, 0, sizeof(Window));

	window->layer = create_layer(frame.size);
	window->size = frame.size;
	window->frame = frame;
	window->border_color = color_make(50, 122, 40);
	window->border_width = 1;
	window->subviews = array_m_create(MAX_ELEMENTS);
	window->title = "Window";
	window->animations = array_m_create(16);

	//root window doesn't have a title view
	if (!root) {
		window->title_view = create_title_view(window);
	}
	window->content_view = create_content_view(window, root);
	window->needs_redraw = 1;
	window->last_draw_timestamp = time();

	//if this window was created by a call to xserv_win_create(),
	//then we're in a syscall handler and getpid() will return the pid of the
	//proc that ran the syscall
	//this is how we know when a user proc is connected to a window
	window->owner_pid = getpid();

	return window;
}
Ejemplo n.º 2
0
void		create_net(t_net *net, t_info info)
{
	int     i;
	int		n_neuron;

	i = 1;
	n_neuron = (info.n_in + info.n_out) / 2;
	net->n_hid = info.n_hid;
	net->n_tot = info.n_hid + 1;
	net->layer = ft_memalloc((info.n_hid + 1) * sizeof(t_layer));
	create_layer(&net->layer[0], info.n_in, n_neuron, 0);
	while (i < net->n_hid)
	{
		create_layer(&net->layer[i], n_neuron, n_neuron, i);
		i++;
	}
	create_layer(&net->layer[i], n_neuron, info.n_out, i);
}
Ejemplo n.º 3
0
void image_new_blank(image_t *image, gdouble rel_w, gdouble rel_h) {
    double w, h;
    get_abs_pos(rel_w, rel_h, &w, &h);
    image->layer = create_layer(w, h);
    image->rotation = 0;
    image->surface = create_surface(w, h);
    image->pbuf = NULL;
    
    add_layer(image->layer);
}
Ejemplo n.º 4
0
Archivo: view.c Proyecto: codyd51/axle
View* create_view(Rect frame) {
	View* view = (View*)kmalloc(sizeof(View));
	view->layer = create_layer(frame.size);
	view->frame = frame;
	view->superview = NULL;
	view->background_color = color_make(0, 255, 0);
	view->subviews = array_m_create(MAX_ELEMENTS);
	view->labels = array_m_create(MAX_ELEMENTS);
	view->bmps = array_m_create(MAX_ELEMENTS);
	view->buttons = array_m_create(MAX_ELEMENTS);
	view->needs_redraw = 1;
	return view;
}
Ejemplo n.º 5
0
/*BeginDocumentation

  Name: topology::CreateLayer - create a spatial layer of nodes

  Synopsis:
  dict CreateLayer -> layer

  Parameters:
  dict - dictionary with layer specification

  Description: The Topology module organizes neuronal networks in
  layers. A layer is a special type of subnet which contains information
  about the spatial position of its nodes. There are three classes of
  layers: grid-based layers, in which each element is placed at a
  location in a regular grid; free layers, in which elements can be
  placed arbitrarily in space; and random layers, where the elements are
  distributed randomly throughout a region in space.  Which kind of layer
  this command creates depends on the elements in the supplied
  specification dictionary.

  Author: Håkon Enger, Kittel Austvoll
*/
void
TopologyModule::CreateLayer_DFunction::execute( SLIInterpreter* i ) const
{
  i->assert_stack_load( 1 );

  DictionaryDatum layer_dict = getValue< DictionaryDatum >( i->OStack.pick( 0 ) );

  index layernode = create_layer( layer_dict );

  i->OStack.pop( 1 );
  i->OStack.push( layernode );
  i->EStack.pop();
}
Ejemplo n.º 6
0
void do_add_layer(GtkWidget *widget, gpointer *data) {
  Layer *lay;
  char **sel = gtk_file_selection_get_selections(GTK_FILE_SELECTION(data));
  for(int c=0;sel[c];c++) {
    func("%s : creating %s",__FUNCTION__,sel[c]);
    lay = create_layer(sel[c]);
    if(!lay) return;
    if(lay->init(env)) {
      env->layers.append(lay);
      env->layers.sel(0); /* deselect others */
      lay->sel(true);
    } else delete lay;
  }
}
Ejemplo n.º 7
0
static View* create_title_view(Window* window) {
	if (!window) return NULL;

	Rect title_view_frame = rect_make(point_make(0, 0), size_make(window->frame.size.width, WINDOW_TITLE_VIEW_HEIGHT));
	View* title_view = create_view(title_view_frame);
	title_view->background_color = window->border_color;

	Button* close_button = create_button(rect_make(point_zero(), size_make(CHAR_WIDTH * 2, title_view->frame.size.height)), "X");
	close_button->mousedown_handler = (event_handler)&close_button_clicked;
	add_button(title_view, close_button);

	Button* minimize_button = create_button(rect_make(point_make(rect_max_x(close_button->frame), 0), size_make(CHAR_WIDTH * 2, title_view->frame.size.height)), "-");
	minimize_button->mousedown_handler = (event_handler)&minimize_button_clicked;
	add_button(title_view, minimize_button);

	//add title label to title view
	int label_length = 20 * CHAR_WIDTH;
	Rect label_frame = rect_make(point_make(rect_max_x(minimize_button->frame) + 15, title_view_frame.size.height / 2 - (CHAR_HEIGHT / 2)), size_make(label_length, CHAR_HEIGHT));
	Label* title_label = create_label(label_frame, window->title);
	title_label->text_color = color_black();
	add_sublabel(title_view, title_label);

	Bmp* dots = create_bmp(title_view_frame, create_layer(title_view_frame.size));
	uint8_t* ref = dots->layer->raw;
	for (int y = 0; y < dots->frame.size.height; y++) {
		for (int x = 0; x < dots->frame.size.width; x++) {
			if (!((x + y) % 2)) {
				*ref++ = 50;
				*ref++ = 50;
				*ref++ = 50;
			}
			else {
				*ref++ = 200;
				*ref++ = 160;
				*ref++ = 90;
			}
		}
	}
	add_bmp(title_view, dots);

	return title_view;
}
Ejemplo n.º 8
0
gboolean image_new(image_t *image, const char *filename) {
    GError **error = NULL;
    image->pbuf = gdk_pixbuf_new_from_file(filename, error);
    if (!image->pbuf)
        return FALSE;
    image->layer = create_layer(gdk_pixbuf_get_width(image->pbuf),
                                gdk_pixbuf_get_height(image->pbuf));
    
    image->rotation = 0;
    
    image->surface = create_surface(image->layer->width, image->layer->height);
    cairo_t *cr = cairo_create(image->surface);
    cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
    gdk_cairo_set_source_pixbuf(cr, image->pbuf, 0, 0);
    cairo_paint(cr);
    cairo_destroy(cr);
    
    add_layer(image->layer);

    return TRUE;
}
Ejemplo n.º 9
0
gboolean load_image(const gchar *filename,
                    gint32      *image_ID,
                    GError     **error)
{
    gboolean              status      = FALSE;
    gchar                *indata      = NULL;
    gsize                 indatalen;
    gint                  width;
    gint                  height;
    WebPMux              *mux         = NULL;
    WebPData              wp_data;
    uint32_t              flags;
    uint8_t              *outdata     = NULL;

#ifdef GIMP_2_9
    /* Initialize GEGL */
    gegl_init(NULL, NULL);
#endif

    do {

        /* Attempt to read the file contents from disk */
        if (g_file_get_contents(filename,
                                &indata,
                                &indatalen,
                                error) == FALSE) {
            break;
        }

        /* Validate WebP data, grabbing the width and height */
        if (!WebPGetInfo(indata, indatalen, &width, &height)) {
            break;
        }

        /* Create a WebPMux from the contents of the file */
        wp_data.bytes = (uint8_t*)indata;
        wp_data.size = indatalen;

        mux = WebPMuxCreate(&wp_data, 1);
        if (mux == NULL) {
            break;
        }

        /* Retrieve the features present */
        if (WebPMuxGetFeatures(mux, &flags) != WEBP_MUX_OK) {
            break;
        }

        /* TODO: decode the image in "chunks" or "tiles" */
        /* TODO: check if an alpha channel is present */

        /* Create the new image and associated layer */
        *image_ID = gimp_image_new(width, height, GIMP_RGB);

#ifdef WEBP_0_5
        if (flags & ANIMATION_FLAG) {
            int frames, i;

            /* Retrieve the number of frames */
            WebPMuxNumChunks(mux, WEBP_CHUNK_ANMF, &frames);

            /* Loop over each of the frames */
            for (i = 0; i < frames; ++i) {
                WebPMuxFrameInfo frame = {0};

                /* Retrieve the data for the frame */
                if (WebPMuxGetFrame(mux, i, &frame) != WEBP_MUX_OK) {
                    goto error;
                }

                /* Decode the frame */
                outdata = WebPDecodeRGBA(frame.bitstream.bytes,
                                         frame.bitstream.size,
                                         &width, &height);

                /* Free the compressed data */
                WebPDataClear(&frame.bitstream);

                if (!outdata) {
                    goto error;
                }

                /* Create a layer for the frame */
                char name[255];
                snprintf(name, 255, "Frame %d", (i + 1));

                if (create_layer(*image_ID,
                                 outdata,
                                 0,
                                 (gchar*)name,
                                 width, height,
                                 frame.x_offset,
                                 frame.y_offset) == FALSE) {
                    goto error;
                }
            }

            /* If all is well, jump *over* the error label - otherwise
               leave the loop and begin cleaning things up */

            goto success;

        error:
            break;

        success: ;

        } else {
#endif

            /* Attempt to decode the data as a WebP image */
            outdata = WebPDecodeRGBA(indata, indatalen, &width, &height);
            if (!outdata) {
                break;
            }

            /* Create a single layer */
            status = create_layer(*image_ID,
                                  outdata,
                                  0,
                                  "Background",
                                  width, height,
                                  0, 0);

#ifdef WEBP_0_5
        }

#ifdef GIMP_2_9
        /* Load a color profile if one was provided */
        if (flags & ICCP_FLAG) {
            WebPData          icc_profile;
            GimpColorProfile *profile;

            /* Load the ICC profile from the file */
            WebPMuxGetChunk(mux, "ICCP", &icc_profile);

            /* Have Gimp load the color profile */
            profile = gimp_color_profile_new_from_icc_profile(
                        icc_profile.bytes, icc_profile.size, NULL);
            if (profile) {
                gimp_image_set_color_profile(image_ID, profile);
                g_object_unref(profile);
            }
        }
#endif
#endif
        /* Set the filename for the image */
        gimp_image_set_filename(*image_ID, filename);

    } while(0);

    /* Delete the mux object */
    if (mux) {
        WebPMuxDelete(mux);
    }

    /* Free the data read from disk */
    if (indata) {
        g_free(indata);
    }

    return status;
}
Ejemplo n.º 10
0
Archivo: view.c Proyecto: elechak/blue
static NATIVECALL(layer_new){
    Link link = create_layer();
    View v = This->value.vptr;
    im_append(v->items, link);
    return link;
}