void ReportWriterWindow::sPrepareWindowMenu() { windowMenu->clear(); int intCascadeid = windowMenu->insertItem(tr("&Cascade"), ws, SLOT(cascade())); int intTileid = windowMenu->insertItem(tr("&Tile"), ws, SLOT(tile())); windowMenu->insertSeparator(); int cnt = 0; QWidgetList windows = ws->windowList(); for (unsigned int intCursor = 0; intCursor < windows.count(); intCursor++) { if(windows.at(intCursor)->isVisible()) { int intMenuid = windowMenu->insertItem(windows.at(intCursor)->caption(), windows.at(intCursor), SLOT(setFocus())); windowMenu->setItemChecked(intMenuid, (ws->activeWindow() == windows.at(intCursor))); cnt++; } } if (cnt < 1) { windowMenu->setItemEnabled(intCascadeid, FALSE); windowMenu->setItemEnabled(intTileid, FALSE); } }
void mission_start::kill_horde_master(mission *miss) { npc *p = g->find_npc(miss->npc_id); p->attitude = NPCATT_FOLLOW;//npc joins you int dist = 0;//pick one of the below locations for the horde to haunt point site = g->cur_om->find_closest(g->om_location(), "office_tower_1", dist, false); if (site.x == -1 && site.y == -1 ) site = g->cur_om->find_closest(g->om_location(), "hotel_tower_1_8", dist, false); if (site.x == -1 && site.y == -1) site = g->cur_om->find_closest(g->om_location(), "school_5", dist, false); if (site.x == -1 && site.y == -1) site = g->cur_om->find_closest(g->om_location(), "forest_thick", dist, false); miss->target = site; // Make it seen on our map for (int x = site.x - 6; x <= site.x + 6; x++) { for (int y = site.y - 6; y <= site.y + 6; y++) g->cur_om->seen(x, y, 0) = true; } tinymap tile(&(g->traps)); tile.load(site.x * 2, site.y * 2, 0, false); tile.add_spawn("mon_zombie_master", 1, SEEX, SEEY, false, -1, miss->uid, "Demonic Soul"); tile.add_spawn("mon_zombie_brute",3,SEEX,SEEY); tile.add_spawn("mon_zombie_fast",3,SEEX,SEEY); if (SEEX > 1 && SEEX < OMAPX && SEEY > 1 && SEEY < OMAPY){ for (int x = SEEX - 1; x <= SEEX + 1; x++) { for (int y = SEEY - 1; y <= SEEY + 1; y++) tile.add_spawn("mon_zombie",rng(3,10),x,y); tile.add_spawn("mon_zombie_fast",rng(0,2),SEEX,SEEY); } } tile.add_spawn("mon_zombie_necro",2,SEEX,SEEY); tile.add_spawn("mon_zombie_hulk",1,SEEX,SEEY); tile.save(g->cur_om, int(g->turn), site.x * 2, site.y * 2, 0); }
bool TileManager::LoadTileInfo( const TiXmlElement *strip ) { std::string tileName, tileType; int tileId = 0; const char *name = strip->Attribute( "name" ); if ( name ) { tileName = name; } else { LogErr( "No name specified for tile." ); return false; } const char *type = strip->Attribute( "type" ); if ( type ) { tileType = type; } else { LogErr( "No type specified for tile." ); return false; } strip->QueryIntAttribute( "id", &tileId ); Tile tile( tileType, tileName, tileId ); m_tileDataName.insert( std::pair<std::string, Tile>( tileName, tile )); m_tileDataId.insert( std::pair<int, Tile*>( tileId, &m_tileDataName[tileName] )); return true; }
bool World::IsBuildTileAccessible(const BuildTile& parBuildTile, const int2& parDimensions) const { assert(parBuildTile.IsValid()); if (!accessibleTile_[parBuildTile.x()][parBuildTile.y()]) return false; BuildTile dimensionInBuildTile(float2(float(parDimensions.x), float(parDimensions.y))); // force conversion const int2& minTile = int2( parBuildTile.x() - 1 - dimensionInBuildTile.w() / 2, parBuildTile.y() - 1 - dimensionInBuildTile.h() / 2); const int2& maxTile = int2( parBuildTile.x() + 1 + dimensionInBuildTile.w() / 2, parBuildTile.y() + 1 + dimensionInBuildTile.h() / 2); for (int x = minTile.x; x <= maxTile.x; ++x) { for (int y = minTile.y; y <= maxTile.y; ++y) { BuildTile tile(x, y); if (!tile.IsValid() || !accessibleTile_[x][y]) return false; } } return true; }
void hc_map::update_tile(hc_connection *con) { hc_tile_info new_info; con->recv(&new_info); vector<hc_tile> *tiles = nullptr; if(new_info.type == 0) { tiles = &background; background_changed = true; } else if(new_info.type == 1) { tiles = &objects; objects_changed = true; } else { hc_fatal << "Unknown tiletype" << endl; exit(0); } for(auto t:*tiles) { if(t.get_ID() == new_info.tile_ID) { t.update(new_info); return; } } hc_tile tile(new_info.tile_ID, new_info); tiles->push_back(tile); }
void StageState::CreateCharacter(int x, int y){ Point tile(x, y); Point tiles = tile; tile = tileMap.GetTileCenter(tile); Permonkey* pM = new Permonkey(tile.x, tile.y, tiles, tileMap, objList); objectArray.emplace_back(pM); }
void findContiguous(const MapTiles &map, TileCoord startTileLocation, std::set<TileCoord, TileCoord::Before> *regionTiles) { regionTiles->clear(); std::set<TileCoord, TileCoord::Before> tilesToExpandFrom; tilesToExpandFrom.insert(startTileLocation); regionTiles->insert(startTileLocation); while (!tilesToExpandFrom.empty()) { TileCoord tileToExpandFrom = *tilesToExpandFrom.begin(); tilesToExpandFrom.erase(tilesToExpandFrom.begin()); for (int rowDelta = -1; rowDelta <= 1; rowDelta++) { for (int colDelta = -1; colDelta <= 1; colDelta++) { if (rowDelta == 0 && colDelta == 0) continue; TileCoord tile(tileToExpandFrom.row + rowDelta, tileToExpandFrom.col + colDelta); if (map[tile] == map[tileToExpandFrom]) { if (regionTiles->find(tile) != regionTiles->end()) continue; regionTiles->insert(tile); tilesToExpandFrom.insert(tile); } } } } // std::cout << "found contiguous block of size " << regionTiles->size() << std::endl; }
void LoadedMap::loadTerrains(XMLElement *element, TileSet *target) { Logger.logMessage(LOG_STATE, LOG_MAP, "LoadedMap::loadTerrains start\n"); assert(element); assert(target); XMLElement *terrain = element->FirstChildElement(XML_TERRAIN.c_str()); Logger.logMessage(LOG_DEBUG, LOG_MAP, "LoadedMap::loadTerrains: Found first terrain\n"); while(terrain) { TerrainType parsed_terrain; parsed_terrain.name = getAttributeString(terrain, XML_TERRAIN_NAME); stringstream tile (terrain->Attribute(XML_TERRAIN_TILE.c_str())); tile >> parsed_terrain.tile; XMLElement *properties = terrain->FirstChildElement(XML_TERRAIN_PROPS.c_str()); if(properties) { loadTerrainProperties(properties, &parsed_terrain); } target->terraintypes.push_back(parsed_terrain); terrain = terrain->NextSiblingElement(); } Logger.logMessage(LOG_STATE, LOG_MAP, "LoadedMap::loadTerrains end\n"); }
void Tileset::Init16bpp(const std::vector<Image16Bpp>& images) { int tile_width = 8 + params.border; const ImageTile& nullTile = ImageTile::GetNullTile(); itiles.insert(nullTile); for (unsigned int k = 0; k < images.size(); k++) { const Image16Bpp& image = images[k]; unsigned int tilesX = image.width / tile_width; unsigned int tilesY = image.height / tile_width; unsigned int totalTiles = tilesX * tilesY; // Perform reduce. for (unsigned int i = 0; i < totalTiles; i++) { int tilex = i % tilesX; int tiley = i / tilesX; ImageTile tile(image, tilex, tiley, params.border); std::set<ImageTile>::iterator foundTile = itiles.find(tile); if (foundTile == itiles.end()) { tile.id = itiles.size(); itiles.insert(tile); } } } }
DrawableTile* CCTiledLayerImpl::createTile(int i, int j) { OwnPtr<DrawableTile> tile(DrawableTile::create()); DrawableTile* addedTile = tile.get(); m_tiler->addTile(tile.release(), i, j); return addedTile; }
dng_tile_iterator::dng_tile_iterator (const dng_point &tileSize, const dng_rect &area) : fArea () , fTileWidth (0) , fTileHeight (0) , fTileTop (0) , fTileLeft (0) , fRowLeft (0) , fLeftPage (0) , fRightPage (0) , fTopPage (0) , fBottomPage (0) , fHorizontalPage (0) , fVerticalPage (0) { dng_rect tile (area); tile.b = Min_int32 (tile.b, tile.t + tileSize.v); tile.r = Min_int32 (tile.r, tile.l + tileSize.h); Initialize (tile, area); }
static void ocean_tile2(struct rect *r, int dx, int dy, int wf, int hf, struct item_bin_sink *out) { struct item_bin *ib=(struct item_bin *)buffer; int w=r->h.x-r->l.x; int h=r->h.y-r->l.y; char tile2[32]; struct rect bbox; struct coord co; bbox.l.x=r->l.x+dx*w; bbox.l.y=r->l.y+dy*h; bbox.h.x=bbox.l.x+w*wf; bbox.h.y=bbox.l.y+h*hf; //fprintf(stderr,"0x%x,0x%x-0x%x,0x%x -> 0x%x,0x%x-0x%x,0x%x\n",r->l.x,r->l.y,r->h.x,r->h.y,bbox.l.x,bbox.l.y,bbox.h.x,bbox.h.y); item_bin_init(ib,type_poly_water_tiled); item_bin_bbox(ib, &bbox); item_bin_write_to_sink(ib, out, NULL); #if 0 item_bin_init(ib, type_border_country); item_bin_bbox(ib, &bbox); item_bin_add_attr_string(ib, attr_debug, tile2); item_bin_write_to_sink(ib, out, NULL); #endif tile(&bbox, NULL, tile2, 32, 0, NULL); co.x=(bbox.l.x+bbox.h.x)/2; co.y=(bbox.l.y+bbox.h.y)/2; //item_bin_write_debug_point_to_sink(out, &co, "%s 15",tile2); }
Colony::~Colony() { disconnect(this, nullptr, tile(), nullptr); m_planet->removeColony(); m_player->removeColony(this); }
TileGroup::TileGroup(BackendType backend_type, TileGroupHeader *tile_group_header, AbstractTable *table, const std::vector<catalog::Schema> &schemas, const column_map_type &column_map, int tuple_count) : database_id(INVALID_OID), table_id(INVALID_OID), tile_group_id(INVALID_OID), backend_type(backend_type), tile_schemas(schemas), tile_group_header(tile_group_header), table(table), num_tuple_slots(tuple_count), column_map(column_map) { tile_count = tile_schemas.size(); for (oid_t tile_itr = 0; tile_itr < tile_count; tile_itr++) { auto &manager = catalog::Manager::GetInstance(); oid_t tile_id = manager.GetNextOid(); std::shared_ptr<Tile> tile(storage::TileFactory::GetTile( backend_type, database_id, table_id, tile_group_id, tile_id, tile_group_header, tile_schemas[tile_itr], this, tuple_count)); // Add a reference to the tile in the tile group tiles.push_back(tile); } }
Image* EXRImageFileReader::read( const char* filename, ImageAttributes* image_attributes) { ProgressiveEXRImageFileReader reader(32, 32); reader.open(filename); CanvasProperties props; reader.read_canvas_properties(props); if (image_attributes) reader.read_image_attributes(*image_attributes); auto_ptr<Image> image( new Image( props.m_canvas_width, props.m_canvas_height, props.m_tile_width, props.m_tile_height, props.m_channel_count, props.m_pixel_format)); for (size_t tile_y = 0; tile_y < props.m_tile_count_y; ++tile_y) { for (size_t tile_x = 0; tile_x < props.m_tile_count_x; ++tile_x) { auto_ptr<Tile> tile(reader.read_tile(tile_x, tile_y)); image->set_tile(tile_x, tile_y, tile.release()); } } reader.close(); return image.release(); }
double tiledInnerParallelGauss(double** a, double* answer, size_t N, int r1, int r2) { makeMainElementNotZero(a, N); // int r1 = 2; // int r2 = 2; int Q1 = N / r1; int Q2 = N / r2; //########## double start = omp_get_wtime(); for (int k = 0; k < N - 1; ++k) { for (int i_gl = 0; i_gl < Q1; ++i_gl) { #pragma omp parallel for for (int j_gl = 0; j_gl < Q2; ++j_gl) { tile(k, i_gl, j_gl, r1, r2, a, N); } } } double finish = omp_get_wtime(); //########## check("Inner", a,answer,N, finish - start); return finish - start; }
void MozQWidgetFast::paint(QPainter* aPainter, const QStyleOptionGraphicsItem*, QWidget*) { // toolbar height int toolbarHeight = 80; // Offset of favicon starting from left toolbar edge int faviconOffset = 25; // favicon size int faviconSize = 32; // width of left and right TOOLBAR_SPLASH part // |------------------------------| // |LeftPart|tile...part|RightPart| float toolbarPartWidth = 77; // width of TOOLBAR_SPLASH part after toolbarPartWidth, // that can be used for tiled toolbar area int tileWidth = 2; // Paint left toolbar part aPainter->drawPixmap(QRect(0, 0, toolbarPartWidth, toolbarHeight), mToolbar, QRect(0, 0, toolbarPartWidth, toolbarHeight)); // Paint Tile pixmap of middle toolbar part QPixmap tile(tileWidth, toolbarHeight); QPainter p(&tile); p.drawPixmap(QRect(0, 0, tileWidth, toolbarHeight), mToolbar, QRect(toolbarPartWidth, 0, tileWidth, toolbarHeight)); aPainter->drawTiledPixmap(QRect(toolbarPartWidth, 0, rect().width() - toolbarPartWidth * 2, toolbarHeight), tile); // Paint Favicon aPainter->drawPixmap(QRect(faviconOffset, faviconOffset, faviconSize, faviconSize), mIcon); if (!mUrl.isEmpty()) { // Height or URL string (font height) float urlHeight = 24.0f; // Start point of URL string, relative to window 0,0 int urlOffsetX = 80; int urlOffsetY = 48; QFont font = aPainter->font(); font.setPixelSize(urlHeight); font.setFamily(QString("Nokia Sans")); font.setKerning(true); aPainter->setFont(font); aPainter->setRenderHint(QPainter::TextAntialiasing, true); aPainter->drawText(urlOffsetX, urlOffsetY, aPainter->fontMetrics().elidedText(mUrl, Qt::ElideRight, rect().width() - urlOffsetX * 2)); } // Paint Right toolbar part aPainter->drawPixmap(QRect(rect().width() - toolbarPartWidth, 0, toolbarPartWidth, toolbarHeight), mToolbar, QRect(mToolbar.width() - toolbarPartWidth, 0, toolbarPartWidth, toolbarHeight)); nsFastStartup::GetSingleton()->painted(); }
void decleftcount(void) { int curid = workspace_get_active(); if (workspace_dec_left_count(curid)) { tile(curid); } }
void decleftwidth(void) { int curid = workspace_get_active(); if (workspace_dec_left_width(curid)) { tile(curid); } }
virtual void Execute(const DataObject &) { RULE.Execute(shRuleUpdateMessageUI, DataObject(stPlaceTheRobber, stWaitingPlaceTheRobber)); //set the dummy selection DummySelectionObject *pSelection = new DummySelectionObject( shRuleExecuteRobberPlacement); //send the dummy selection object up Controller::get().Transmit(shEventSelectionObject, SelectionObjectPtr(pSelection)); // Make sure eveything is hidden. Controller::get().Transmit(shEventBuildUI, DataObject(false, GetGame())); Controller::get().Transmit(shEventControlsUI, DataObject(false)); RULE.Execute(shRuleResetTileFlags, DataObject(IGameObject::Dim)); // They can't place the robber on the current robber tile. const HexObjectPtr& robber = GetGame()->getHexObject(shRobber); wxInt32 robberTile = robber->tile(); if(true == robber->isset(IGameObject::Hidden)) { robberTile = -1; } // Turn on all land tiles except the robber tile. wxInt32 tiles = numTiles(); for(wxInt32 i = 0; i < tiles; ++i) { if(i != robberTile) { DataObject input(i), output; RULE.Decide(shLogicTileIsLand, input, output); if(true == output.read<bool>()) { tile(i)->reset(); tile(i)->set(IGameObject::Select); } } } }
//return a new image from a tile in this image Image * Image::createImageFromThis(int tileNum, int iAlpha /*=-1*/) { SDL_Rect r = tile(tileNum, _tileW, _tileH); Image *image = new Image(r.w, r.h, iAlpha); image->blitFrom(this, tileNum); image->setTileSize(_tileW, _tileH); return image; }
static void update_fog_after_move (Unit *u){ Mcrd m; FOR_EACH_MCRD(m){ if(mdist(m, u->m) <= utypes[u->t].v) tile(m)->visible = true; } }
static void draw_fog (void){ Mcrd m; FOR_EACH_MCRD(m){ if(!tile(m)->visible) draw_img(img_fog_of_war, map2scr(m)); } }
static void draw_map (void){ Mcrd m; FOR_EACH_MCRD(m){ SDL_Surface *s = img_tiles[tile(m)->t]; draw_img(s, map2scr(m)); } }
//----------------------------------------------------------------------------- //init the image fragment tile -- virtual function //----------------------------------------------------------------------------- void Compose_Viewer::init_ift() { m_ift = new ImageFragment_Tile(0, 0, gw, gh); //single tile viewer NodeRectile tile(1, m_gw, m_gh); m_ift->set_tile(&tile); }
void KviMdiManager::destroyChild(KviMdiChild *lpC) { removeSubWindow(lpC); delete lpC; if(!m_bInSDIMode && KVI_OPTION_BOOL(KviOption_boolAutoTileWindows)) tile(); }
MdiContainerWidgetTaskMenu::MdiContainerWidgetTaskMenu(QWorkspace *m, QObject *parent) : ContainerWidgetTaskMenu(m, MdiContainer, parent) { initializeActions(); connect(m_nextAction, SIGNAL(triggered()), m, SLOT(activateNextWindow())); connect(m_previousAction, SIGNAL(triggered()), m, SLOT(activatePreviousWindow())); connect(m_tileAction, SIGNAL(triggered()),m , SLOT(tile())); connect(m_cascadeAction, SIGNAL(triggered()), m, SLOT(cascade())); }
void Frustum::tileFrustum(U32 numTiles, const Point2I& curTile, Point2F overlap) { //These will be stored to re-tile the frustum if needed mNumTiles = numTiles; mCurrTile = curTile; mTileOverlap = overlap; tile(&mNearLeft, &mNearRight, &mNearTop, &mNearBottom, mNumTiles, mCurrTile, mTileOverlap); }
OublietteLevel::~OublietteLevel() { for (int y = 0; y < m_size.height(); ++y) { for (int x = 0; x < m_size.width(); ++x) { qDeleteAll(tile(x, y).items); } } delete [] m_map; }
UpdatableTile* TiledLayerChromium::createTile(int i, int j) { OwnPtr<UpdatableTile> tile(UpdatableTile::create(textureUpdater()->createTexture(textureManager()))); UpdatableTile* addedTile = tile.get(); m_tiler->addTile(tile.release(), i, j); addedTile->m_dirtyRect = m_tiler->tileRect(addedTile); return addedTile; }