bool Layer::swapKeyFrames( int position1, int position2 ) //Current behaviour, need to refresh the swapped cels { bool keyPosition1 = false, keyPosition2 = false; KeyFrame* pFirstFrame; KeyFrame* pSecondFrame; if ( keyExists( position1 ) ) { auto firstFrame = mKeyFrames.find( position1 ); pFirstFrame = firstFrame->second; mKeyFrames.erase( position1 ); //pFirstFrame = getKeyFrameAtPosition( position1 ); //removeKeyFrame( position1 ); keyPosition1 = true; } if ( keyExists( position2 ) ) { auto secondFrame = mKeyFrames.find( position2 ); pSecondFrame = secondFrame->second; mKeyFrames.erase( position2 ); //pSecondFrame = getKeyFrameAtPosition( position2 ); //removeKeyFrame( position2 ); keyPosition2 = true; } if ( keyPosition2 ) { //addKeyFrame( position1, pSecondFrame ); pSecondFrame->setPos( position1 ); mKeyFrames.insert( std::make_pair( position1, pSecondFrame ) ); } else if ( position1 == 1 ) { addNewKeyAt( position1 ); } if ( keyPosition1 ) { //addKeyFrame( position2, pFirstFrame ); pFirstFrame->setPos( position2 ); mKeyFrames.insert( std::make_pair( position2, pFirstFrame ) ); } else if ( position2 == 1 ) { addNewKeyAt( position2 ); } return true; }
bool isChain(const std::string src, const std::string tgt) { std::cout << src << " == " << tgt << std::endl; if ((!keyExists(src)) || (!keyExists(tgt))) { return false; } // obvious base case - both phrases are the same if (src == tgt) { return true; } return false; }
bool AttrList_setItem(AttrList l, String key, int v){ bool retVal = false; int idx = -1; size_t i; String tmpKey; idx = getIndex(l); if(idx >= 0){ if(!keyExists(l, key)){ if(attrListPool[idx].length == (attrListPool[idx].size - 1)){ growList(idx, (attrListPool[idx].size * 2)); } for(i = 0; i < attrListPool[idx].size; ++i){ if(attrListPool[idx].keys[i] == INVALID_STRING){ break; } } tmpKey = new_String(NULL); if(tmpKey != INVALID_STRING && String_copyString(tmpKey, key)){ attrListPool[idx].keys[i] = tmpKey; attrListPool[idx].data[i] = v; attrListPool[idx].length++; retVal = true; } } } return retVal; }
void SpriteManager::addSpriteSheet(const std::string &key, const char *fname, SDL_Rect r, int w, int h, int border,unsigned transp) { if (fileExists(fname)) { SDL_Surface * image = IMG_Load(fname); int iw = image->w; int ih = image->h; SDL_Surface * tmp = SDL_CreateRGBSurface(0, w, h, 32, 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000); Uint32 *pixels = (Uint32 *)tmp->pixels; Uint32 *origpixels = (Uint32 *)image->pixels; int c = 0; for (int i = border; i < iw-w; i += w + border) { for (int j = border; j < ih-h; j += h + border) { for (int x = 0; x < w; ++x) { for (int y = 0; y < h; ++y) { if ((origpixels[(j + y)*iw + (i + x)] ^ transp) == 0) pixels[x + y*w] = 0; else pixels[x + y*w] = origpixels[(j + y)*iw + (i + x)]; } } std::string tmpkey = key + std::to_string(c); ++c; if (!keyExists(tmpkey)) { list[tmpkey] = Sprite(SDL_CreateTextureFromSurface(renderer, tmp), r, w, h); log(VERBOSE_LOAD, "LOADED SPRITESHEET %s FROM %s", tmpkey.c_str(), fname); } else { log(VERBOSE_ERRORS, "Repeated sprite key %s", tmpkey.c_str()); } } } } else { log(VERBOSE_ERRORS, "File not found %s", fname); } }
std::string OptionsWrapper::getSingleValue(const std::string& key, Enum::GameOption modmapFlag) const { Enum::OptionType optType = Enum::opt_undefined; if (keyExists(key, modmapFlag, false, optType)) { GameOptionsMapCIter optIt = m_opts.find((int)modmapFlag); if (optIt == m_opts.end()) return ""; const GameOptions& tempOpt = optIt->second; switch (optType) { case Enum::opt_float: return Util::ToFloatString(GetItem(tempOpt.float_map, key).value); case Enum::opt_bool: return Util::ToIntString(GetItem(tempOpt.bool_map, key).value); case Enum::opt_string: return GetItem(tempOpt.string_map, key).value; case Enum::opt_list: return GetItem(tempOpt.list_map, key).value; case Enum::opt_undefined: default: return ""; } } return ""; }
bool Editor::importBitmapImage( QString filePath ) { backup( tr( "ImportImg" ) ); QImageReader reader( filePath ); Q_ASSERT( layers()->currentLayer()->type() == Layer::BITMAP ); auto layer = static_cast<LayerBitmap*>( layers()->currentLayer() ); QImage img( reader.size(), QImage::Format_ARGB32_Premultiplied ); while ( reader.read( &img ) ) { if ( img.isNull() || reader.nextImageDelay() <= 0 ) { break; } if ( !layer->keyExists( currentFrame() ) ) { addNewKey(); } BitmapImage* bitmapImage = layer->getBitmapImageAtFrame( currentFrame() ); QRect boundaries = img.rect(); boundaries.moveTopLeft( mScribbleArea->getCentralPoint().toPoint() - QPoint( boundaries.width() / 2, boundaries.height() / 2 ) ); BitmapImage* importedBitmapImage = new BitmapImage( boundaries, img ); bitmapImage->paste( importedBitmapImage ); scrubTo( currentFrame() + 1 ); } return true; }
std::vector<double> XConf::splitValueDouble( const std::string &key, double def, const xstring &separator ) const { if (!keyExists(key)) return std::vector<double>(); std::vector<xstring> v = getValue(key).split(separator); std::vector<double> v2; for (int i=0; i<v.size(); ++i) v2.push_back( v[i].toDouble(def) ); return v2; }
bool OptionsWrapper::setSingleOption(const std::string& key, const std::string& value) { Enum::OptionType optType = Enum::opt_undefined; if (keyExists(key, Enum::ModOption, false, optType)) { return setSingleOptionTypeSwitch(key, value, Enum::ModOption, optType); } return false; }
Enum::OptionType OptionsWrapper::GetSingleOptionType(const std::string& key) const { Enum::OptionType type = Enum::opt_undefined; for (int g = 0; g < Enum::LastOption; g++) { if (keyExists(key, (Enum::GameOption)g, false, type)) return type; } return Enum::opt_undefined; }
void ArgumentVector::push_back(std::string key, std::string value) { if (keyExists(key)) { printd(WARNING, "ArgumentVector::push_back(): inserting duplicate entry for key %s! First entry will be removed!\n", key.c_str()); arguments.erase(key); } // if arguments.insert(make_pair(key, Argument(value))); } // push_back
void LayerCamera::loadImageAtFrame( int frameNumber, QTransform view ) { if ( keyExists( frameNumber ) ) { removeKeyFrame( frameNumber ); } Camera* camera = new Camera( view ); camera->setPos( frameNumber ); addKeyFrame( frameNumber, camera ); }
OptionType OptionsWrapper::GetSingleOptionType ( const wxString& key) const { OptionType type = opt_undefined; for ( int g = 0; g < LastOption; g++ ) { if (keyExists(key,(GameOption)g,false,type)) return type; } return opt_undefined; }
bool OptionsWrapper::keyExists(const std::string& key) const { bool found = false; for (int flag = 0; flag < Enum::PrivateOptions; flag++) { Enum::OptionType optType = Enum::opt_undefined; found = keyExists(key, (Enum::GameOption)flag, false, optType); if (found) break; } return found; }
bool AttrList_replaceItem(AttrList l, String key, int v){ bool retVal = true; if(keyExists(l, key)){ retVal = AttrList_deleteItem(l, key); } if(retVal){ retVal = AttrList_setItem(l, key, v); } return retVal; }
//------------------------------------------------------------------------- //-- Attach this object to the registry CTinyCadRegistry::CTinyCadRegistry() : CRegistry() { m_oKey.Create(HKEY_CURRENT_USER, M_SKEY); // Does the registry information exist - if not create it if (!keyExists(M_SPAGESIZE)) { CreateDefaultEntries(); } }
bool OptionsWrapper::keyExists( const wxString& key ) const { bool found = false; for ( int flag = 0; flag < PrivateOptions; flag++ ) { OptionType optType = opt_undefined; found = keyExists( key, (GameOption)flag, false, optType ); if ( found ) break; } return found; }
bool Editor::importBitmapImage( QString filePath ) { backup( tr( "ImportImg" ) ); qDebug(filePath.toLatin1().data()); QImageReader reader( filePath ); Q_ASSERT( layers()->currentLayer()->type() == Layer::BITMAP ); auto layer = static_cast<LayerBitmap*>( layers()->currentLayer() ); QImage img;//( reader.size(), QImage::Format_ARGB32_Premultiplied ); img.load(filePath); while ( reader.read( &img ) ) {/* if ( img.isNull() || reader.nextImageDelay() <= 0 ) { qDebug("why not image"); break; }*/ if ( !layer->keyExists( currentFrame() ) ) { qDebug("why not imagesadfsdaf ssd"); addNewKey(); } BitmapImage* bitmapImage = layer->getBitmapImageAtFrame( currentFrame() ); QRect boundaries = img.rect(); boundaries.moveTopLeft( mScribbleArea->getCentralPoint().toPoint() - QPoint( boundaries.width() / 2, boundaries.height() / 2 ) ); BitmapImage* importedBitmapImage = new BitmapImage( boundaries, img ); bitmapImage->paste( importedBitmapImage ); if(layers()->currentLayerIndex()>2) { //下面用来框出倒入的图片 mScribbleArea->mySelection.moveTopLeft(mScribbleArea->getCentralPoint().toPoint() - QPoint( boundaries.width()/1.5, boundaries.height()/1.5) );//这个是为了将值赋给QRectF mScribbleArea->mySelection.moveBottomRight(mScribbleArea->getCentralPoint().toPoint() + QPoint( boundaries.width()/1.5, boundaries.height()/1.5)); mScribbleArea->mySelection.setTopLeft(mScribbleArea->getCentralPoint().toPoint() - QPoint( boundaries.width()/1.5, boundaries.height()/1.5)); mScribbleArea->mySelection.setBottomRight(mScribbleArea->getCentralPoint().toPoint() + QPoint( boundaries.width()/1.5, boundaries.height()/1.5)); //mScribbleArea->mySelection.moveBottomRight(QPoint( boundaries.width()/2, boundaries.height()/2)); mScribbleArea->setSelection( mScribbleArea->mySelection, true ); mScribbleArea->myTransformedSelection = mScribbleArea->mySelection.adjusted( 0, 0, 0, 0 ); mScribbleArea->myTempTransformedSelection = mScribbleArea->mySelection.adjusted( 0, 0, 0, 0 ); mScribbleArea->update(); mScribbleArea->mIncludeImg[mLayerManager->currentLayerIndex()]=mScribbleArea->mySelection; tools()->setCurrentTool(MOVE); } // scrubTo( currentFrame() + 1 ); } return true; }
void LayerVector::loadImageAtFrame(QString path, int frameNumber) { if ( keyExists( frameNumber ) ) { removeKeyFrame( frameNumber, false ); } VectorImage* vecImg = new VectorImage; vecImg->setPos( frameNumber ); vecImg->setObject( object() ); vecImg->read( path ); addKeyFrame( frameNumber, vecImg ); }
Enum::GameOption OptionsWrapper::GetSection(const std::string& key) const { Enum::GameOption ret = Enum::LastOption; bool found = false; for (int flag = 0; flag < Enum::PrivateOptions; flag++) { Enum::OptionType optType = Enum::opt_undefined; found = keyExists(key, (Enum::GameOption)flag, false, optType); if (found) { ret = (Enum::GameOption)flag; break; } } return ret; }
void ConfigFile::extractContents(const std::string &line) { std::string temp = line; temp.erase(0, temp.find_first_not_of("\t ")); size_t sepPos = temp.find('='); std::string key, value; extractKey(key, sepPos, temp); extractValue(value, sepPos, temp); if (!keyExists(key)) contents.insert(std::pair<std::string, std::string > (key, value)); else std::cout << "CFG: Can only have unique key names!\n" << std::endl; }
int LayerManager::LastFrameAtFrame( int frameIndex ) { Object* pObj = editor()->object(); for ( int i = frameIndex; i >= 0; i -= 1 ) { for ( int layerIndex = 0; layerIndex < pObj->getLayerCount(); ++layerIndex ) { auto pLayer = pObj->getLayer( layerIndex ); if ( pLayer->keyExists( i ) ) { return i; } } } return -1; }
OptionsWrapper::GameOption OptionsWrapper::GetSection( const wxString& key ) const { GameOption ret = LastOption; bool found = false; for ( int flag = 0; flag < PrivateOptions; flag++ ) { OptionType optType = opt_undefined; found = keyExists( key, (GameOption)flag, false, optType ); if ( found ) { ret = (GameOption)flag; break; } } return ret; }
std::string OptionsWrapper::GetNameListOptValue(const std::string& key, Enum::GameOption flag) const { Enum::OptionType optType; if (keyExists(key, flag, false, optType)) { if (optType == Enum::opt_list) { GameOptionsMapCIter optIt = m_opts.find((int)flag); if (optIt == m_opts.end()) return ""; GameOptions tempOpt = optIt->second; return ((tempOpt.list_map)[key].cbx_choices[(tempOpt.list_map)[key].cur_choice_index]); } } // at this point retrieval failed return ""; }
bool OptionsWrapper::setOptions(stringPairVec* options, Enum::GameOption modmapFlag) { for (stringPairVec::const_iterator it = options->begin(); it != options->end(); ++it) { std::string key = it->first; std::string value = it->second; //we don't want to add a key that doesn't already exists Enum::OptionType optType = Enum::opt_undefined; if (!keyExists(key, modmapFlag, false, optType)) return false; else { if (!setSingleOptionTypeSwitch(key, value, modmapFlag, optType)) return false; } } return true; }
void SpriteManager::addImage(const std::string &key, const char *fname, SDL_Rect r) { // check if key exists if (!keyExists(key)) { if (fileExists(fname)) { SDL_Surface * image = IMG_Load(fname); list[key] = Sprite(SDL_CreateTextureFromSurface(renderer, image), r,image->w,image->h); SDL_FreeSurface(image); log(VERBOSE_LOAD, "LOADED SPRITESHEET %s FROM %s",key.c_str(), fname); } else { log(VERBOSE_ERRORS, "File not found %s", fname); } } else { log(VERBOSE_ERRORS, "Repeated sprite key %s", key.c_str()); } }
virtual StatusWith<SpecialFormatInserted> insert(OperationContext* opCtx, const BSONObj& key, const RecordId& loc, bool dupsAllowed) { invariant(loc.isValid()); invariant(!hasFieldNames(key)); // TODO optimization: save the iterator from the dup-check to speed up insert if (!dupsAllowed && keyExists(*_data, key)) return buildDupKeyErrorStatus(key, _collectionNamespace, _indexName, _keyPattern); IndexKeyEntry entry(key.getOwned(), loc); if (_data->insert(entry).second) { _currentKeySize += key.objsize(); opCtx->recoveryUnit()->registerChange(new IndexChange(_data, entry, true)); } return StatusWith<SpecialFormatInserted>(SpecialFormatInserted::NoSpecialFormatInserted); }
void SpriteManager::addText(const std::string &key, const char *text, const SDL_Color &color, int ptsize, const char* fontfile, SDL_Rect r) { if (!keyExists(key)) { if (fileExists(fontfile)) { TTF_Font* font; font = TTF_OpenFont(fontfile, ptsize); SDL_Surface *image = TTF_RenderText_Blended(font, text, color); list[key] = Sprite(SDL_CreateTextureFromSurface(renderer, image), r, image->w, image->h); SDL_FreeSurface(image); TTF_CloseFont(font); log(VERBOSE_LOAD, "LOADED TEXT %s [%s] USING %s", key.c_str(), text, fontfile); } else { log(VERBOSE_ERRORS, "File not found %s", fontfile); } } else { log(VERBOSE_ERRORS, "Repeated sprite key %s", key.c_str()); } }
std::string OptionsWrapper::GetNameListOptItemKey(const std::string& optkey, const std::string& itemname, Enum::GameOption flag) const { Enum::OptionType optType; if (keyExists(optkey, flag, false, optType)) { if (optType == Enum::opt_list) { GameOptionsMapCIter optIt = m_opts.find((int)flag); if (optIt == m_opts.end()) return ""; GameOptions tempOpt = optIt->second; for (ListItemVec::const_iterator it = (tempOpt.list_map)[optkey].listitems.begin(); it != (tempOpt.list_map)[optkey].listitems.end(); ++it) { if (it->name == itemname) return it->key; } } } // at this point retrieval failed return ""; }
bool Editor::importBitmapImage(QString filePath, int space) { QImageReader reader(filePath); Q_ASSERT(layers()->currentLayer()->type() == Layer::BITMAP); auto layer = static_cast<LayerBitmap*>(layers()->currentLayer()); QImage img(reader.size(), QImage::Format_ARGB32_Premultiplied); if (img.isNull()) { return false; } while (reader.read(&img)) { if (!layer->keyExists(currentFrame())) { addNewKey(); } BitmapImage* bitmapImage = layer->getBitmapImageAtFrame(currentFrame()); BitmapImage importedBitmapImage(mScribbleArea->getCentralPoint().toPoint() - QPoint(img.width() / 2, img.height() / 2), img); bitmapImage->paste(&importedBitmapImage); if (space > 1) { scrubTo(currentFrame() + space); } else { scrubTo(currentFrame() + 1); } backup(tr("Import Image")); // Workaround for tiff import getting stuck in this loop if (!reader.supportsAnimation()) { break; } } return true; }
std::string OptionsWrapper::getDefaultValue(const std::string& key, Enum::GameOption modmapFlag) const { Enum::OptionType optType = Enum::opt_undefined; std::string ret; if (keyExists(key, modmapFlag, false, optType)) { //purposefully create a copy, no better idea GameOptionsMapCIter optIt = m_opts.find((int)modmapFlag); if (optIt == m_opts.end()) return ""; const GameOptions& tempOpt = optIt->second; switch (optType) { { case Enum::opt_bool: ret = Util::ToIntString(GetItem(tempOpt.bool_map, key).def); break; } case Enum::opt_float: { ret = Util::ToFloatString(GetItem(tempOpt.float_map, key).def); break; } case Enum::opt_string: { ret = GetItem(tempOpt.string_map, key).def; break; } case Enum::opt_list: { ret = GetItem(tempOpt.list_map, key).def; break; } default: { break; } } } return ret; }