void clear_virtscreen(struct virtscreen *cur, int mode) { switch (mode) { case 0: clear_region(cur,cur->ypos,cur->xpos, cur->rows-1,cur->columns-1,cur->attrib); break; case 1: clear_region(cur,0,0,cur->ypos,cur->xpos,cur->attrib); break; default: clear_region(cur,0,0,cur->rows-1,cur->columns-1,cur->attrib); cur->xpos = cur->ypos = 0; break; } }
void SLsmg_erase_eos (void) { if (Smg_Inited == 0) return; SLsmg_erase_eol (); clear_region (This_Row + 1, (int)Screen_Rows, 0x20); }
void ugrid_scroll(UGrid *grid, int count, int *clear_top, int *clear_bot) { // Compute start/stop/step for the loop below int start, stop, step; if (count > 0) { start = grid->top; stop = grid->bot - count + 1; step = 1; } else { start = grid->bot; stop = grid->top - count - 1; step = -1; } int i; // Copy cell data for (i = start; i != stop; i += step) { UCell *target_row = grid->cells[i] + grid->left; UCell *source_row = grid->cells[i + count] + grid->left; memcpy(target_row, source_row, sizeof(UCell) * (size_t)(grid->right - grid->left + 1)); } // clear cells in the emptied region, if (count > 0) { *clear_top = stop; *clear_bot = stop + count - 1; } else { *clear_bot = stop; *clear_top = stop + count + 1; } clear_region(grid, *clear_top, *clear_bot, grid->left, grid->right); }
/* Taking in a Map, renders a line on the game board. Last two parameters act as bit flags for the rendering: bDrawFlag | bAND | Result 0 1 - Clear the whole line 0 0 - Clear active bits 1 1 - Draw active and clear inactive 1 0 - Draw only active */ void render_Line( UINT16* fbBase16, UINT16 iMap, int iYPxlPos, UINT8 bDrawFlag, bool bAND ) { UINT16 i, iXPxlPos = (BOARD_DRAW_END_X - MINO_SIZE); UINT16 iYPxlEndPos; UINT8 bActiveBit; if( iYPxlPos >= 0 && iYPxlPos < SCREEN_HEIGHT ) { iYPxlEndPos = iYPxlPos + MINO_SIZE; for( i = 0; i < BOARD_WIDTH; i++ ) { bActiveBit = (iMap & (TETRI_MAP_BASE - 1)); if( bDrawFlag && bActiveBit ) draw_bitmap_16( fbBase16, iXPxlPos, iYPxlPos, iMinoBitmap, BMP_HEIGHT ); else if( bAND || bActiveBit) clear_region( fbBase16, iXPxlPos, iXPxlPos + MINO_SIZE, iYPxlPos, iYPxlEndPos ); iMap >>= 1; iXPxlPos -= MINO_SIZE; } }
void clear_to_eol(struct virtscreen *cur, int mode) { switch(mode) { case 0: clear_region(cur,cur->ypos,cur->xpos,cur->ypos, cur->columns-1,cur->attrib); break; case 1: clear_region(cur,cur->ypos,0,cur->ypos,cur->xpos, cur->attrib); break; default: clear_region(cur,cur->ypos,0,cur->ypos,cur->columns-1, cur->attrib); } }
/** * gimp_projection_initialize: * @proj: A #GimpProjection. * @x: * @y: * @w: * @h: * * This function determines whether a visible layer with combine mode * Normal provides complete coverage over the specified area. If not, * the projection is initialized to transparent black. */ static void gimp_projection_initialize (GimpProjection *proj, gint x, gint y, gint w, gint h) { GList *list; gint proj_off_x; gint proj_off_y; gboolean coverage = FALSE; gimp_projectable_get_offset (proj->projectable, &proj_off_x, &proj_off_y); for (list = gimp_projectable_get_layers (proj->projectable); list; list = g_list_next (list)) { GimpLayer *layer = list->data; GimpDrawable *drawable = GIMP_DRAWABLE (layer); GimpItem *item = GIMP_ITEM (layer); gint off_x, off_y; gimp_item_get_offset (item, &off_x, &off_y); /* subtract the projectable's offsets because the list of * update areas is in tile-pyramid coordinates, but our * external API is always in terms of image coordinates. */ off_x -= proj_off_x; off_y -= proj_off_y; if (gimp_item_get_visible (item) && ! gimp_drawable_has_alpha (drawable) && ! gimp_layer_get_mask (layer) && gimp_layer_get_mode (layer) == GIMP_NORMAL_MODE && gimp_layer_get_opacity (layer) == GIMP_OPACITY_OPAQUE && off_x <= x && off_y <= y && (off_x + gimp_item_get_width (item)) >= (x + w) && (off_y + gimp_item_get_height (item)) >= (y + h)) { coverage = TRUE; break; } } if (! coverage) { PixelRegion region; pixel_region_init (®ion, gimp_pickable_get_tiles (GIMP_PICKABLE (proj)), x, y, w, h, TRUE); clear_region (®ion); } }
void SLsmg_cls (void) { int tac; if (Smg_Inited == 0) return; tac = This_Alt_Char; This_Alt_Char = 0; SLsmg_set_color (0); clear_region (0, (int)Screen_Rows, 0x20); This_Alt_Char = tac; SLsmg_set_color (0); Cls_Flag = 1; }
/* Draws the FPS in the top left corner of the screen or clears it based on the FPS render flags. */ void render_FPS( UINT8* fbBase8, int iValue ) { if( sMainState[ iCurrState ].bRenderFPS ) { render_Value( fbBase8, iValue, 0, 0 ); sMainState[ iCurrState ].bRenderFPS = false; } else if( sMainState[ iCurrState ].bClearFPS ) { clear_region( (UINT16*)fbBase8, 0, TEXT_WIDTH << 1, 0, TEXT_HEIGHT ); sMainState[ iCurrState ].bClearFPS = false; } }
void clear_whole_screen(void) { struct rccoord start = { 0, 0 }; DWORD dwConSize; CONSOLE_SCREEN_BUFFER_INFO record; // get buffer size GetConsoleScreenBufferInfo(STDCONSOLE, &record); dwConSize = record.dwSize.X * record.dwSize.Y; clear_region(start, dwConSize); // home cursor SetConsoleCursorPosition(STDCONSOLE, rccoord_to_COORD(start)); return; }
int init_virtscreen(struct virtscreen *cur, int rows, int columns) { cur->num_bytes = ((sizeof(unsigned short) * rows * columns)); if (!(cur->data=malloc(cur->num_bytes))) return (-1); cur->data_off_scr = cur->data; cur->bottom_scroll = cur->rows = rows; cur->columns = columns; cur->cur_ansi_number = cur->top_scroll = 0; cur->ansi_elements = cur->ansi_reading_number = 0; cur->next_char_send = std_interpret_char; cur->old_attrib = cur->attrib = 0x07; cur->next_char_send = std_interpret_char; clear_region(cur,0,0,rows-1,columns-1,cur->attrib); cur->old_xpos = cur->old_ypos = 0; return (0); }
DiplomacyRegion::~DiplomacyRegion() { clear_region(); }
static GimpLayer * gimp_image_merge_layers (GimpImage *image, GSList *merge_list, GimpContext *context, GimpMergeType merge_type, const gchar *undo_desc) { GList *list; GSList *reverse_list = NULL; PixelRegion src1PR, src2PR, maskPR; PixelRegion *mask; GimpLayer *merge_layer; GimpLayer *layer; GimpLayer *bottom_layer; GimpImageType type; gint count; gint x1, y1, x2, y2; gint x3, y3, x4, y4; CombinationMode operation; gint position; gboolean active[MAX_CHANNELS] = { TRUE, TRUE, TRUE, TRUE }; gint off_x, off_y; gchar *name; g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL); layer = NULL; type = GIMP_RGBA_IMAGE; x1 = y1 = 0; x2 = y2 = 0; bottom_layer = NULL; /* Get the layer extents */ count = 0; while (merge_list) { layer = merge_list->data; gimp_item_offsets (GIMP_ITEM (layer), &off_x, &off_y); switch (merge_type) { case GIMP_EXPAND_AS_NECESSARY: case GIMP_CLIP_TO_IMAGE: if (! count) { x1 = off_x; y1 = off_y; x2 = off_x + gimp_item_width (GIMP_ITEM (layer)); y2 = off_y + gimp_item_height (GIMP_ITEM (layer)); } else { if (off_x < x1) x1 = off_x; if (off_y < y1) y1 = off_y; if ((off_x + gimp_item_width (GIMP_ITEM (layer))) > x2) x2 = (off_x + gimp_item_width (GIMP_ITEM (layer))); if ((off_y + gimp_item_height (GIMP_ITEM (layer))) > y2) y2 = (off_y + gimp_item_height (GIMP_ITEM (layer))); } if (merge_type == GIMP_CLIP_TO_IMAGE) { x1 = CLAMP (x1, 0, gimp_image_get_width (image)); y1 = CLAMP (y1, 0, gimp_image_get_height (image)); x2 = CLAMP (x2, 0, gimp_image_get_width (image)); y2 = CLAMP (y2, 0, gimp_image_get_height (image)); } break; case GIMP_CLIP_TO_BOTTOM_LAYER: if (merge_list->next == NULL) { x1 = off_x; y1 = off_y; x2 = off_x + gimp_item_width (GIMP_ITEM (layer)); y2 = off_y + gimp_item_height (GIMP_ITEM (layer)); } break; case GIMP_FLATTEN_IMAGE: if (merge_list->next == NULL) { x1 = 0; y1 = 0; x2 = gimp_image_get_width (image); y2 = gimp_image_get_height (image); } break; } count ++; reverse_list = g_slist_prepend (reverse_list, layer); merge_list = g_slist_next (merge_list); } if ((x2 - x1) == 0 || (y2 - y1) == 0) return NULL; /* Start a merge undo group. */ gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_IMAGE_LAYERS_MERGE, undo_desc); name = g_strdup (gimp_object_get_name (GIMP_OBJECT (layer))); if (merge_type == GIMP_FLATTEN_IMAGE || gimp_drawable_type (GIMP_DRAWABLE (layer)) == GIMP_INDEXED_IMAGE) { guchar bg[4] = { 0, 0, 0, 0 }; type = GIMP_IMAGE_TYPE_FROM_BASE_TYPE (gimp_image_base_type (image)); merge_layer = gimp_layer_new (image, (x2 - x1), (y2 - y1), type, gimp_object_get_name (GIMP_OBJECT (layer)), GIMP_OPACITY_OPAQUE, GIMP_NORMAL_MODE); if (! merge_layer) { g_warning ("%s: could not allocate merge layer.", G_STRFUNC); return NULL; } GIMP_ITEM (merge_layer)->offset_x = x1; GIMP_ITEM (merge_layer)->offset_y = y1; /* get the background for compositing */ gimp_image_get_background (image, context, gimp_drawable_type (GIMP_DRAWABLE (merge_layer)), bg); /* init the pixel region */ pixel_region_init (&src1PR, gimp_drawable_get_tiles (GIMP_DRAWABLE (merge_layer)), 0, 0, (x2 - x1), (y2 - y1), TRUE); /* set the region to the background color */ color_region (&src1PR, bg); position = 0; } else { /* The final merged layer inherits the name of the bottom most layer * and the resulting layer has an alpha channel whether or not the * original did. Opacity is set to 100% and the MODE is set to normal. */ merge_layer = gimp_layer_new (image, (x2 - x1), (y2 - y1), gimp_drawable_type_with_alpha (GIMP_DRAWABLE (layer)), "merged layer", GIMP_OPACITY_OPAQUE, GIMP_NORMAL_MODE); if (!merge_layer) { g_warning ("%s: could not allocate merge layer", G_STRFUNC); return NULL; } GIMP_ITEM (merge_layer)->offset_x = x1; GIMP_ITEM (merge_layer)->offset_y = y1; /* clear the layer */ pixel_region_init (&src1PR, gimp_drawable_get_tiles (GIMP_DRAWABLE (merge_layer)), 0, 0, (x2 - x1), (y2 - y1), TRUE); clear_region (&src1PR); /* Find the index in the layer list of the bottom layer--we need this * in order to add the final, merged layer to the layer list correctly */ layer = reverse_list->data; position = gimp_container_num_children (image->layers) - gimp_container_get_child_index (image->layers, GIMP_OBJECT (layer)); } bottom_layer = layer; /* Copy the tattoo and parasites of the bottom layer to the new layer */ gimp_item_set_tattoo (GIMP_ITEM (merge_layer), gimp_item_get_tattoo (GIMP_ITEM (bottom_layer))); g_object_unref (GIMP_ITEM (merge_layer)->parasites); GIMP_ITEM (merge_layer)->parasites = gimp_parasite_list_copy (GIMP_ITEM (bottom_layer)->parasites); while (reverse_list) { GimpLayerModeEffects mode; layer = reverse_list->data; /* determine what sort of operation is being attempted and * if it's actually legal... */ operation = gimp_image_merge_layers_get_operation (merge_layer, layer); if (operation == -1) { gimp_layer_add_alpha (layer); /* try again ... */ operation = gimp_image_merge_layers_get_operation (merge_layer, layer); } if (operation == -1) { g_warning ("%s: attempting to merge incompatible layers.", G_STRFUNC); return NULL; } gimp_item_offsets (GIMP_ITEM (layer), &off_x, &off_y); x3 = CLAMP (off_x, x1, x2); y3 = CLAMP (off_y, y1, y2); x4 = CLAMP (off_x + gimp_item_width (GIMP_ITEM (layer)), x1, x2); y4 = CLAMP (off_y + gimp_item_height (GIMP_ITEM (layer)), y1, y2); /* configure the pixel regions */ pixel_region_init (&src1PR, gimp_drawable_get_tiles (GIMP_DRAWABLE (merge_layer)), (x3 - x1), (y3 - y1), (x4 - x3), (y4 - y3), TRUE); pixel_region_init (&src2PR, gimp_drawable_get_tiles (GIMP_DRAWABLE (layer)), (x3 - off_x), (y3 - off_y), (x4 - x3), (y4 - y3), FALSE); if (gimp_layer_get_mask (layer) && gimp_layer_mask_get_apply (layer->mask)) { TileManager *tiles; tiles = gimp_drawable_get_tiles (GIMP_DRAWABLE (layer->mask)); pixel_region_init (&maskPR, tiles, (x3 - off_x), (y3 - off_y), (x4 - x3), (y4 - y3), FALSE); mask = &maskPR; } else { mask = NULL; } /* DISSOLVE_MODE is special since it is the only mode that does not * work on the projection with the lower layer, but only locally on * the layers alpha channel. */ mode = gimp_layer_get_mode (layer); if (layer == bottom_layer && mode != GIMP_DISSOLVE_MODE) mode = GIMP_NORMAL_MODE; combine_regions (&src1PR, &src2PR, &src1PR, mask, NULL, gimp_layer_get_opacity (layer) * 255.999, mode, active, operation); gimp_image_remove_layer (image, layer); reverse_list = g_slist_next (reverse_list); } g_slist_free (reverse_list); /* if the type is flatten, remove all the remaining layers */ if (merge_type == GIMP_FLATTEN_IMAGE) { list = GIMP_LIST (image->layers)->list; while (list) { layer = list->data; list = g_list_next (list); gimp_image_remove_layer (image, layer); } gimp_image_add_layer (image, merge_layer, position); } else { /* Add the layer to the image */ gimp_image_add_layer (image, merge_layer, gimp_container_num_children (image->layers) - position + 1); } /* set the name after the original layers have been removed so we * don't end up with #2 appended to the name */ gimp_object_take_name (GIMP_OBJECT (merge_layer), name); gimp_item_set_visible (GIMP_ITEM (merge_layer), TRUE, TRUE); /* End the merge undo group */ gimp_image_undo_group_end (image); gimp_drawable_update (GIMP_DRAWABLE (merge_layer), 0, 0, gimp_item_width (GIMP_ITEM (merge_layer)), gimp_item_height (GIMP_ITEM (merge_layer))); return merge_layer; }
void ugrid_clear(UGrid *grid) { clear_region(grid, 0, grid->height-1, 0, grid->width-1, HLATTRS_INIT); }
void ugrid_clear_chunk(UGrid *grid, int row, int col, int endcol, HlAttrs attrs) { clear_region(grid, row, row, col, endcol-1, attrs); }
void ugrid_clear(UGrid *grid) { clear_region(grid, grid->top, grid->bot, grid->left, grid->right); }
void ugrid_clear_chunk(UGrid *grid, int row, int col, int endcol, sattr_T attr) { clear_region(grid, row, row, col, endcol-1, attr); }
void ugrid_clear(UGrid *grid) { clear_region(grid, 0, grid->height-1, 0, grid->width-1, 0); }
DiplomacyRegion::DiplomacyRegion(char *name, DiplomacyGame *gamep) { clear_region(); names.push_back(strdup(name)); game = gamep; }
void ugrid_eol_clear(UGrid *grid) { clear_region(grid, grid->row, grid->row, grid->col, grid->right); }