cellwidget.c

添加系统调用。。。在LINUX下添加一个新的系统调用。在文件中添加自己的系统调用的源代码

                g_object_unref(layout);
        }

        /* Insertion arrows */
        if (!invalid && inserting &&
            (current_cell == i || current_cell == i + 1)) {
                double width, stem, height;

                cairo_set_source_gdk_color(cairo, &color_select, 1.);
                width = CELL_BORDER;
                stem = CELL_BORDER / 2;
                height = CELL_BORDER;
                if ((!right_to_left && current_cell == i) ||
                    (right_to_left && current_cell == i + 1)) {

                        /* Top right arrow */
                        cairo_move_to(cairo, x, y + 1);
                        cairo_line_to(cairo, x + stem, y + 1);
                        cairo_line_to(cairo, x + stem, y + height);
                        cairo_line_to(cairo, x + width, y + height);
                        cairo_line_to(cairo, x, y + height * 2);
                        cairo_close_path(cairo);
                        cairo_fill(cairo);

                        /* Bottom right arrow */
                        cairo_move_to(cairo, x, y + cell_height - 1);
                        cairo_line_to(cairo, x + stem, y + cell_height - 1);
                        cairo_line_to(cairo, x + stem,
                                      y + cell_height - height);
                        cairo_line_to(cairo, x + width,
                                      y + cell_height - height);
                        cairo_line_to(cairo, x, y + cell_height - height * 2);
                        cairo_close_path(cairo);
                        cairo_fill(cairo);

                } else if ((!right_to_left && current_cell == i + 1) ||
                           (right_to_left && current_cell == i)) {
                        double ox;

                        ox = i % cell_cols == cell_cols - 1 ? 0. : 1.;

                        /* Top left arrow */
                        cairo_move_to(cairo, x + cell_width + ox, y + 1);
                        cairo_line_to(cairo, x + cell_width - stem + ox,
                                      y + 1);
                        cairo_line_to(cairo, x + cell_width - stem + ox,
                                      y + height);
                        cairo_line_to(cairo, x + cell_width - width + ox,
                                      y + height);
                        cairo_line_to(cairo, x + cell_width + ox,
                                      y + height * 2);
                        cairo_close_path(cairo);
                        cairo_fill(cairo);

                        /* Bottom left arrow */
                        cairo_move_to(cairo, x + cell_width + ox,
                                      y + cell_height - 1);
                        cairo_line_to(cairo, x + cell_width - stem + ox,
                                      y + cell_height - 1);
                        cairo_line_to(cairo, x + cell_width - stem + ox,
                                      y + cell_height - height);
                        cairo_line_to(cairo, x + cell_width - width + ox,
                                      y + cell_height - height);
                        cairo_line_to(cairo, x + cell_width + ox,
                                      y + cell_height - height * 2);
                        cairo_close_path(cairo);
                        cairo_fill(cairo);

                }
        }

        gtk_widget_queue_draw_area(drawing_area, x, y, cell_width, cell_height);
        pc->flags &= ~CELL_DIRTY;

        /* This cell may have dirtied the on-screen keyboard */
        if (show_keys && x < key_widget->x + key_widget->width &&
                         y < key_widget->y + key_widget->height &&
                         x + cell_width > key_widget->x &&
                         y + cell_height > key_widget->y)
                keys_dirty = TRUE;
}

static void render_dirty(void)
/* Render cells marked dirty */
{
        int i;

        for (i = cell_row_view * cell_cols; i < cell_rows * cell_cols; i++)
                if (cells[i].flags & CELL_DIRTY)
                        render_cell(i);
        if (show_keys && keys_dirty) {
                key_widget_render(key_widget);
                keys_dirty = FALSE;
        }
}

void cell_widget_render(void)
/* Render the cells */
{
        int i, cols, rows, width, height;

        if (!cairo || !pixmap || !pixmap_gc)
                return;

        /* On-screen keyboard eats up some cells on the end */
        cols = cell_cols;
        if (show_keys)
                cols -= KEY_WIDGET_COLS;

        /* Render cells */
        for (i = cell_row_view * cols; i < cell_rows * cols; i++)
                render_cell(i);

        /* Draw border */
        rows = cell_rows < cell_rows_pref ? cell_rows : cell_rows_pref;
        width = cell_width * cols + 1;
        height = cell_height * rows + 1;
        gdk_gc_set_rgb_fg_color(pixmap_gc, &color_bg_dark);
        if (!right_to_left)
                gdk_draw_rectangle(pixmap, pixmap_gc, FALSE, 0, 0,
                                   width, height);
        else
                gdk_draw_rectangle(pixmap, pixmap_gc, FALSE,
                                   drawing_area->allocation.width - width - 1,
                                   0, width, height);

        /* Fill extra space to the right */
        gdk_gc_set_rgb_fg_color(pixmap_gc, &color_bg);
        if (!right_to_left)
                gdk_draw_rectangle(pixmap, pixmap_gc, TRUE, width + 1, 0,
                                   drawing_area->allocation.width - width,
                                   height + 1);
        else
                gdk_draw_rectangle(pixmap, pixmap_gc, TRUE, 0, 0,
                                   drawing_area->allocation.width - width - 1,
                                   height + 1);

        /* Fill extra space below */
        gdk_draw_rectangle(pixmap, pixmap_gc, TRUE, 0, height + 1,
                           drawing_area->allocation.width,
                           drawing_area->allocation.height - height + 1);

        /* Render the on-screen keyboard */
        if (show_keys) {
                key_widget_render(key_widget);
                keys_dirty = FALSE;
        }

        /* Dirty the entire drawing area */
        gtk_widget_queue_draw(drawing_area);
}

static void clear_cell(int i)
{
        Cell *cell;

        cell = cells + i;
        cell->flags = 0;
        if (cell->ch || i == current_cell) {
                if (i == current_cell)
                        input = NULL;
                cell->flags |= CELL_DIRTY;
        }
        clear_sample(&cell->sample);
        cell->ch = 0;
        cell->alts[0] = NULL;
}

static void pad_cell(int cell)
{
        int i;

        /* Turn any blank cells behind the cell into spaces */
        for (i = cell - 1; i >= 0 && !cells[i].ch; i--) {
                cells[i].ch = ' ';
                cells[i].flags |= CELL_DIRTY;
        }
}

static void free_cells(void)
/* Free sample data */
{
        int i;

        if (!cells)
                return;
        for (i = 0; i < cell_rows * cell_cols; i++)
                clear_cell(i);
        g_free(cells);
        cells = NULL;
        input = NULL;
}

static void wrap_cells(int new_rows, int new_cols)
/* Word wrap cells */
{
        Cell *new_cells;
        int i, j, size, row, col, break_i = -1, break_j = -1;

        /* Allocate and clear the new grid */
        if (new_rows < 1)
                new_rows = 1;
        size = new_rows * new_cols * sizeof (Cell);
        new_cells = g_malloc0(size);

        for (i = 0, j = 0, row = 0, col = 0; i < cell_rows * cell_cols; i++) {
                if (!cells[i].ch)
                        continue;

                /* Break at non-alphanumeric characters */
                if (!g_unichar_isalnum(cells[i].ch)) {
                        break_i = i;
                        break_j = j;
                }

                if (col >= new_cols) {

                        /* If we need to, allocate room for the new row */
                        if (++row >= new_rows) {
                                size = ++new_rows * new_cols * sizeof (Cell);
                                new_cells = g_realloc(new_cells, size);
                                memset(new_cells + (new_rows - 1) * new_cols,
                                       0, new_cols * sizeof (Cell));
                        }

                        /* Move any hanging words down to the next row */
                        size = i - break_i - 1;
                        if (size >= 0 && size < i - 1) {
                                memset(new_cells + break_j + 1, 0,
                                       sizeof (Cell) * size);
                                i = break_i + 1;
                                break_i = -1;
                        }
                        col = 0;
                        if (!cells[i].ch)
                                continue;
                }
                new_cells[j++] = cells[i];
                col++;
        }

        /* If we have filled the last row, we need to add a new row */
        if (col >= new_cols && row >= new_rows - 1) {
                size = ++new_rows * new_cols * sizeof (Cell);
                new_cells = g_realloc(new_cells, size);
                memset(new_cells + (new_rows - 1) * new_cols, 0,
                       new_cols * sizeof (Cell));
        }

        /* Only free the cell array, NOT the samples as we have copied the
           Sample data over to the new cell array */
        g_free(cells);
        cells = new_cells;

        /* Scroll the grid */
        if (new_rows > cell_rows && new_rows > cell_rows_pref)
                cell_row_view += new_rows - cell_rows;

        /* Do not let the row view look too far down */
        if (cell_row_view + cell_rows_pref > new_rows) {
                cell_row_view = new_rows - cell_rows_pref;
                if (cell_row_view < 0)
                        cell_row_view = 0;
        }

        cell_rows = new_rows;
        cell_cols = new_cols;
}

static int set_size_request(int force)
/* Resize the drawing area if necessary */
{
        int new_w, new_h, rows, resized;

        new_w = cell_cols * cell_width + 2;
        rows = cell_rows;
        if (rows > cell_rows_pref)
                rows = cell_rows_pref;
        new_h = rows * cell_height + 2;
        resized = new_w != drawing_area->allocation.width ||
                  new_h != drawing_area->allocation.height || force;
        if (!resized)
                return FALSE;
        gtk_widget_set_size_request(drawing_area, new_w, new_h);
        return TRUE;
}

static int pack_cells(int new_rows, int new_cols)
/* Pack and position cells, resize widget and window when necessary.
   Returns TRUE if the widget was resized in the process and can expect a
   configure event in the near future. */
{
        int i, rows, range, new_range;

        /* Must have at least one row */
        if (new_rows < 1)
                new_rows = 1;

        /* Word wrapping will perform its own memory allocation */
        if (!training && cells)
                wrap_cells(new_rows, new_cols);

        else if (!cells || new_rows != cell_rows || new_cols != cell_cols) {

                /* Find minimum number of rows necessary */
                if (cells) {
                        for (i = cell_rows * cell_cols - 1; i > 0; i--)
                                if (cells[i].ch)
                                        break;
                        rows = i / new_cols + 1;
                        if (new_rows < rows)
                                new_rows = rows;
                        new_range = new_rows * new_cols;

                        /* If we have shrunk the grid, clear cells outside */
                        range = cell_rows * cell_cols;
                        for (i = new_range; i < range; i++)
                                clear_cell(i);
                } else {
                        range = 0;
                        new_range = new_rows * new_cols;
                }

                /* Allocate enough room, clear any new cells */
                cells = g_realloc(cells, new_rows * new_cols * sizeof (Cell));
                if (new_range > range)
                        memset(cells + range, 0,
                               (new_range - range) * sizeof (Cell));

                cell_rows = new_rows;
                cell_cols = new_cols;
        }
        dirty_all();

        /* Update the scrollbar */
        if (cell_rows <= cell_rows_pref) {
                cell_row_view = 0;
                gtk_widget_hide(scrollbar);
        } else {
                GtkObject *adjustment;

                if (cell_row_view > cell_rows - cell_rows_pref)
                        cell_row_view = cell_rows - cell_rows_pref;
                if (cell_row_view < 0)
                        cell_row_view = 0;
                adjustment = gtk_adjustment_new(cell_row_view, 0, cell_rows, 1,
                                                cell_rows_pref, cell_rows_pref);
                gtk_range_set_adjustment(GTK_RANGE(scrollbar),
                                         GTK_ADJUSTMENT(adjustment));
                gtk_widget_show(scrollbar);
        }

        return set_size_request(FALSE);
}

static void stop_timeout(void)
{
        if (!timeout_source)
                return;
        g_source_remove(timeout_source);
        timeout_source = 0;
}

static void finish_cell(int cell)
{
        stop_timeout();
        if (cell < 0 || cell >= cell_rows * cell_cols ||
            !input || input->len < 1)
                return;
        cells[cell].flags |= CELL_DIRTY;

        /* Train on the input */
        if (training)
                train_sample(&cells[cell].sample, TRUE);

        /* Recognize input */
        else if (input && input->strokes[0] && input->strokes[0]->len) {
                Cell *pc = cells + cell;
                int i;

                /* Track stats */
                if (pc->ch && pc->ch != ' ')
                        rewrites++;
                inputs++;