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);
}
Example #3
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;
}
Example #4
0
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;
}
Example #5
0
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);
}
Example #7
0
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;
}
Example #8
0
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");
}
Example #9
0
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);
            }
        }
    }
}
Example #10
0
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);

}
Example #12
0
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);
}
Example #13
0
Colony::~Colony()
{
    disconnect(this, nullptr, tile(), nullptr);

    m_planet->removeColony();
    m_player->removeColony(this);
}
Example #14
0
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();
}
Example #18
0
void decleftcount(void)
{
	int curid = workspace_get_active();

	if (workspace_dec_left_count(curid)) {
		tile(curid);
	}
}
Example #19
0
void decleftwidth(void)
{
	int curid = workspace_get_active();

	if (workspace_dec_left_width(curid)) {
		tile(curid);
	}
}
Example #20
0
	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);
				}
			}
		}
	}
Example #21
0
//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;
}
Example #22
0
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;
  }
}
Example #23
0
static void
draw_fog (void){
  Mcrd m;
  FOR_EACH_MCRD(m){
    if(!tile(m)->visible)
      draw_img(img_fog_of_war, map2scr(m));
  }
}
Example #24
0
static void
draw_map (void){
  Mcrd m;
  FOR_EACH_MCRD(m){
    SDL_Surface *s = img_tiles[tile(m)->t];
    draw_img(s, map2scr(m));
  }
}
Example #25
0
//-----------------------------------------------------------------------------
//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);
}
Example #26
0
void KviMdiManager::destroyChild(KviMdiChild *lpC)
{
	removeSubWindow(lpC);
	delete lpC;

	if(!m_bInSDIMode && KVI_OPTION_BOOL(KviOption_boolAutoTileWindows))
		tile();
}
Example #27
0
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);
}
Example #29
0
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;
}
Example #30
0
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;
}