//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAvatarImagePanel::PaintBackground( void )
{
vgui::IImage *pImage = GetImage();
if ( pImage )
{
pImage->SetColor( GetDrawColor() );
pImage->Paint();
}
}
MonoClass* MonoEmbedding::GetClass()
{
static MonoClass* klass;
if (!klass)
klass = mono_class_from_name(GetImage(), "", "MonoEmbedding");
return klass;
}
void CCompositeImageDesc::MarkImage (const CCompositeImageSelector &Selector, DWORD dwModifiers)
// MarkImage
//
// Marks the image in use
{
GetImage(Selector, dwModifiers).MarkImage();
}
OP_STATUS HEListElm::SendImageFinishedLoadingEvent(FramesDocument* doc)
{
OP_ASSERT(doc);
OP_ASSERT(!GetEventSent());
if (inline_type == IMAGE_INLINE && HElm()->GetInserted() == HE_INSERTED_BY_PARSE_AHEAD)
{
HElm()->SetSpecialBoolAttr(ATTR_JS_DELAYED_ONLOAD, TRUE, SpecialNs::NS_LOGDOC);
return OpStatus::OK;
}
// Since this requires decoding the image, skip it if there are no event listeners
if (inline_type == IMAGE_INLINE &&
(GetElm()->HasEventHandler(doc, ONLOAD) || GetElm()->HasEventHandler(doc, ONERROR)))
{
LoadInlineElm* lie = GetLoadInlineElm();
OP_ASSERT(lie);
URLStatus url_status = lie->GetUrl()->Status(TRUE);
if (url_status == URL_LOADED)
{
#ifdef SVG_SUPPORT
// If it is an svg image wait with sending onerror or
// onload until it has been parsed.
if (lie->GetUrl()->ContentType() == URL_SVG_CONTENT)
return OpStatus::OK;
#endif // SVG_SUPPORT
Image img = GetImage();
// IsAnimated() implies that the first frame is decoded which is good enough for us.
if (img.ImageDecoded() || img.IsAnimated())
return OnLoad();
if (GetUrlContentProvider() && !GetImageVisible())
{
/* Force image decoding, so that we can send onload or onerror as appropriate. */
OP_STATUS status = img.IncVisible(this);
if (OpStatus::IsSuccess(status))
{
// Scripts might load image in a hidden place and move
// on load, in which case we don't want image to be
// re-decoded.
ImageManager::GraceTimeLock lock(imgManager);
// This will send onload or onerror through the ImageListener callbacks (OnError and OnPortionDecoded).
// except for animated images since only the first frame will be decoded.
status = img.OnLoadAll(GetUrlContentProvider());
img.DecVisible(this);
OP_ASSERT(GetEventSent());
}
return status;
}
}
else if (url_status == URL_LOADING_FAILURE)
SendOnError();
}
return OpStatus::OK;
}
void CAvatarImagePanel::SetAvatarBySteamID( CSteamID *friendsID )
{
if ( !GetImage() )
{
CAvatarImage *pImage = new CAvatarImage();
SetImage( pImage );
}
// Indent the image. These are deliberately non-resolution-scaling.
int iIndent = 2;
GetImage()->SetPos( iIndent, iIndent );
int wide = GetWide() - (iIndent*2);
((CAvatarImage*)GetImage())->SetAvatarSize( ( wide > 32 ) ? k_EAvatarSize64x64 : k_EAvatarSize32x32 );
((CAvatarImage*)GetImage())->SetAvatarSteamID( *friendsID );
GetImage()->SetSize( wide, GetTall()-(iIndent*2) );
}
/*****************************************************************************
* FUNCTION
* mmi_java_entry_terminate_dialog
* DESCRIPTION
* The entry function to ask user if they want to terminate/Pause Java
* PARAMETERS
* void
* RETURNS
* void
*****************************************************************************/
void mmi_java_entry_terminate_dialog(void) /* called by JAVA adaptor, also in mmi task */
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
U8 *guiBuffer;
U8 *icon_items[2];
U8 *text_items[2];
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
EntryNewScreen(
SCR_JAVA_TERMINATE_DIALOG,
mmi_java_entry_terminate_dialog_exit,
mmi_java_entry_terminate_dialog,
NULL);
guiBuffer = GetCurrGuiBuffer(SCR_JAVA_TERMINATE_DIALOG);
RegisterHighlightHandler(mmi_java_highlight_handler);
memset(icon_items, 0, sizeof(icon_items));
text_items[0] = (PU8) GetString(STR_JAVA_PAUSE);
text_items[1] = (PU8) GetString(STR_JAVA_TERMINATE);
ShowCategory32Screen(
format_asking_string(STR_JAVA_TERMINATE_DIALOG_TITLE),
NULL,
(PU8) GetString(STR_GLOBAL_OK),
(PU8) GetImage(IMG_GLOBAL_OK),
(PU8) GetString(STR_GLOBAL_BACK),
(PU8) GetImage(IMG_GLOBAL_BACK),
2,
text_items,
icon_items,
0,
0,
guiBuffer);
SetLeftSoftkeyFunction(mmi_java_terminate_dialog_yes_hdlr, KEY_EVENT_UP);
SetRightSoftkeyFunction(mmi_java_terminate_dialog_no_hdlr, KEY_EVENT_UP);
}
/*
功能：第二次确认指纹并注册指纹
成功返回SUCCESS，失败返回错误码
*/
int Java_xwp_jr_Fingerprint_SecondReg(JNIEnv *env, jclass thiz)
{
int ret = ACK_NOFINGER;
int count = 0;
if(OPENED != fd_status)
{
LOGE("设备未打开");
goto EXIT;
}
while(ret == ACK_NOFINGER)
{
if(count > OVERTIME)
break;
LOGI("获取第二次指纹中。。。。");
ret = GetImage();
count++;
usleep(DELAYTIME);
}
if(ret != SUCCESS)
{
LOGE("第二次获取指纹失败。。。");
goto EXIT;
}
ret = GenChar(charbuffer2);
if(ret != SUCCESS)
{
LOGE("生成指纹特征库失败");
goto EXIT;
}
ret = RegModel();
if(ret != SUCCESS)
{
LOGE("合并指纹失败");
goto EXIT;
}
ret = StoreChar(charbuffer2, finger_id);
if(ret != SUCCESS)
{
LOGE("存储指纹失败");
goto EXIT;
}
finger_id++;
LOGI("注册指纹总数：%d", finger_id);
EXIT:
status = VERIFY;
return ret;
}
VOID CSizeImageDlg::DoSizeInits( )
{
HWND hDlg = GetSafeHwnd();
LPFRAME lpFrame;
LPIMAGE lpImage = GetImage();
FRMDATATYPE Type = FDT_RGBCOLOR;
ImgGetInfo(lpImage, NULL, NULL, NULL, &Type);
/* Be careful to set all values before doing a SetDlg... with them */
/* The Edit structure is a temorary holding area for sizing dialog boxes */
m_Distortable = NO;
m_MaintainSize = NO;
m_ScaleX = m_ScaleY = 100;
if ( lpImage )
{
lpFrame = ImgGetBaseEditFrame(lpImage);
m_Crop.left = m_Crop.top = 0;
m_Crop.right = lpImage->npix - 1;
m_Crop.bottom = lpImage->nlin - 1;
m_Resolution = m_CropResolution = m_OrigResolution =
FrameResolution(lpFrame);
m_Depth = FrameDepth(lpFrame);
}
else
{
m_Resolution = m_CropResolution = 75;
m_Depth = 1;
}
m_Angle = 0;
m_Width = FGET( CROPWIDTH(), m_CropResolution );
m_Height = FGET( CROPHEIGHT(), m_CropResolution );
CheckDlgButton( IDC_DISTORT, m_Distortable);
CheckDlgButton( IDC_SMARTSIZE, m_SmartSize );
CheckDlgButton( IDC_MAINTAINSIZE, m_MaintainSize );
ControlEnable(hDlg, IDC_DISTORT, !m_MaintainSize);
ControlEnable(hDlg, IDC_MAINTAINSIZE, !m_Distortable );
ControlEnable( hDlg, IDC_SMARTSIZE, !m_MaintainSize &&
!m_Distortable && CANDOTRANSPARENCY(Type));
InitDlgItemSpinFixed( hDlg, IDC_HEIGHT, m_Height, YES, 0L, FGET(9999,1) );
InitDlgItemSpinFixed( hDlg, IDC_WIDTH, m_Width, YES, 0L, FGET(9999,1) );
InitDlgItemSpin( hDlg, IDC_SCALEX, m_ScaleX, YES, 1, 10000 );
InitDlgItemSpin( hDlg, IDC_SCALEY, m_ScaleY, YES, 1, 10000 );
InitDlgItemSpin( hDlg, IDC_RES, m_Resolution, NO, 1, 10000 );
ImageMemory( hDlg, IDC_MEMORY, m_Width, m_Height, m_Resolution,
m_Depth );
CheckComboItem(hDlg, IDC_PREF_UNITS, IDC_PREF_UNITFIRST,
IDC_PREF_UNITLAST, m_Units);
SetUnitLabels();
}
void CUnitVolumeMakerDlg::GetVolume(int iWidth,
int iLength,
int iHeight,
EZoomOut eZoomOutLevel)
{
int iZ = 0;
for(iZ = 0; iZ < m_TissueBlock.m_UnitCube.m_nHeight; iZ++)
GetImage(iWidth, iLength, iHeight, iZ, eZoomOutLevel);
}
ALERROR CGImageCache::LockImageSurface (int iIndex, CGLockedSurface *pLockedSurface)
// LockImageSurface
//
// Locks the image and fill-in the locked surface object
{
IMAGEDATASTRUCT *pData = GetImage(iIndex);
return pLockedSurface->Create(pData->pSurface, NULL, pData->pTrans, NULL);
}
House::House(glm::vec3 pos, sf::Color color, int houseType, int roofType, float length, float width, float height = 10.f)
: SceneObject(pos)
,roof(GetImage( std::string(RoofTypeNames[roofType]) + ".png"))
,side(GetImage( std::string(HouseTypeNames[houseType]) + ".png"))
,color(color)
,length(length)
,width(width)
,height(height)
{
// roof.Bind();
// glEnable(GL_TEXTURE_2D);
// glGenerateMipmap(true);
// glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
// side.Bind();
// glEnable(GL_TEXTURE_2D);
// glGenerateMipmap(true);
// glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
}
VulkanDescriptorSet *VkHardwareTexture::GetDescriptorSet(const FMaterialState &state)
{
FMaterial *mat = state.mMaterial;
FTexture *tex = state.mMaterial->tex;
int clampmode = state.mClampMode;
int translation = state.mTranslation;
if (tex->UseType == ETextureType::SWCanvas) clampmode = CLAMP_NOFILTER;
if (tex->isHardwareCanvas()) clampmode = CLAMP_CAMTEX;
else if ((tex->isWarped() || tex->shaderindex >= FIRST_USER_SHADER) && clampmode <= CLAMP_XY) clampmode = CLAMP_NONE;
// Textures that are already scaled in the texture lump will not get replaced by hires textures.
int flags = state.mMaterial->isExpanded() ? CTF_Expand : (gl_texture_usehires && !tex->isScaled() && clampmode <= CLAMP_XY) ? CTF_CheckHires : 0;
if (tex->isHardwareCanvas()) static_cast<FCanvasTexture*>(tex)->NeedUpdate();
for (auto &set : mDescriptorSets)
{
if (set.descriptor && set.clampmode == clampmode && set.flags == flags) return set.descriptor.get();
}
int numLayers = mat->GetLayers();
auto fb = GetVulkanFrameBuffer();
auto descriptor = fb->GetRenderPassManager()->AllocateTextureDescriptorSet(numLayers);
descriptor->SetDebugName("VkHardwareTexture.mDescriptorSets");
VulkanSampler *sampler = fb->GetSamplerManager()->Get(clampmode);
WriteDescriptors update;
update.addCombinedImageSampler(descriptor.get(), 0, GetImage(tex, translation, flags)->View.get(), sampler, mImage.Layout);
for (int i = 1; i < numLayers; i++)
{
FTexture *layer;
auto systex = static_cast<VkHardwareTexture*>(mat->GetLayer(i, 0, &layer));
update.addCombinedImageSampler(descriptor.get(), i, systex->GetImage(layer, 0, mat->isExpanded() ? CTF_Expand : 0)->View.get(), sampler, systex->mImage.Layout);
}
update.updateSets(fb->device);
mDescriptorSets.emplace_back(clampmode, flags, std::move(descriptor));
return mDescriptorSets.back().descriptor.get();
}
/* ------------------------------------------------------------------------------------ */
bool CAnimGif::DisplayNextFrameTexture(const char *szTextureName, bool FFrame)
{
if(!Active)
return false;
if(FFrame)
{
geBitmap_Info Info;
geBitmap *theBitmap = geWorld_GetBitmapByName(CCD->World(), szTextureName);
if(!theBitmap)
{
Active = false;
return false;
}
geBitmap_GetInfo(theBitmap, &Info, NULL);
if(nWidth!=Info.Width || nHeight!=Info.Height)
{
Active = false;
return false;
}
if(theBmp)
{
// changed QD 12/15/05
geEngine_RemoveBitmap(CCD->Engine()->Engine(), theBmp);
// end change
geBitmap_Destroy(&theBmp);
}
theBmp = theBitmap;
Texture = true;
TotalReadByte = 0;
pcGifTrack=pcGif;
VAnimTime = (float)CCD->FreeRunningCounter();
if(GetImage(true))
{
FirstFrame = false;
return true;
}
FirstFrame = false;
return false;
}
else
{
NextFrame(true);
}
return true;
}
void QtGameWidget::paintEvent(QPaintEvent *)
{
QPainter painter(this);
const int width = this->width();
const int height = this->height();
const double scale_x
= static_cast<double>(width)
/ TankBattalion::GetArenaWidth();
const double scale_y
= static_cast<double>(height)
/ TankBattalion::GetArenaHeight();
painter.setBackgroundMode(Qt::TransparentMode);
painter.drawImage(
this->rect(),
*GetImage(TankBattalion::arena).get());
painter.drawImage(
QRect(0,0,scale_x * 16.0, scale_y * 16.0),
*GetImage(TankBattalion::player_left).get());
}
/*****************************************************************************
* FUNCTION
* mmi_rmgr_list_ro_entry_option
* DESCRIPTION
* Entry function of the list ro option screen
* PARAMETERS
* void
* RETURNS
* void
*****************************************************************************/
static void mmi_rmgr_list_ro_entry_option(void)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
U16 g_id;
U16 menu_cui_id;
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
g_id = mmi_frm_group_create(GRP_ID_RMGR_MAIN, GRP_ID_RMGR_RO_OPTIONS, mmi_rmgr_ro_options_evt_hdlr, NULL);
mmi_frm_group_enter(g_id, MMI_FRM_NODE_SMART_CLOSE_FLAG);
menu_cui_id = cui_menu_create(
g_id,
CUI_MENU_SRC_TYPE_RESOURCE,
CUI_MENU_TYPE_OPTION,
MENU_ID_RMGR_RO_OPTIONS,
MMI_FALSE,
NULL);
cui_menu_set_default_title_image(menu_cui_id,(UI_image_type)GetImage(mmi_rmgr_get_root_icon()));
cui_menu_run(menu_cui_id);
#if 0
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
#endif /*0*/
}
void TopLevel::newPage(){
if(!display_is_setup)
SetupDisplay();
XDefineCursor(qtdisplay, Win, WorkCursor);
XFlush(qtdisplay);
freeImages();
int k = -1;
if(!thispage) {
XDefineCursor(qtdisplay, Win, ReadyCursor);
return;
}
if (Pimage(thispage) == NULL){
while((k != 0) && (k != 3) && (k !=1))
k = GetImage(thispage);
}
if (k == 3 ){
XDefineCursor(qtdisplay, Win, ReadyCursor);
FreeFax();
/* KMessageBox::sorry(i18n("Bad fax file k=3"));*/
return;
}
if (k == 0 ){
XDefineCursor(qtdisplay, Win, ReadyCursor);
FreeFax();
/* KMessageBox::sorry(i18n("Bad fax file k=0"));*/
return;
}
Image = Images[0] = Pimage(thispage);
setCaption(QFile::decodeName(thispage->name));
Image = generateZoomImages(oz);
PaneWidth = Image->width;
PaneHeight = Image->height;
Refresh = 1;
XDefineCursor(qtdisplay, Win, ReadyCursor);
uiUpdate();
}
void Target::Run()
{
printf("Target::Run running...\n");
while (1) {
if (m_newImage && GetImage()) {
printf("Target::Run got image\n");
m_pTop = m_pBottom = m_pLeft = m_pRight = NULL;
m_leftX = m_rightX = -1;
bool result = FindParticles() && AnalyzeParticles();
{
Synchronized mutex(m_sem);
m_newImage = false;
m_processingComplete = true;
m_targetsFound = result;
if (result) {
m_targetCenter.angle = m_centerAngle;
m_targetCenter.distance = m_centerDistance;
m_targetCenter.valid = true;
m_targetTop.angle = m_topAngle;
//m_targetTop.distance = m_topDistance;
m_targetTop.distance = m_centerDistance;
m_targetTop.valid = (m_pTop != NULL);
m_targetBottom.angle = m_bottomAngle;
//m_targetBottom.distance = m_bottomDistance;
m_targetBottom.distance = m_centerDistance;
m_targetBottom.valid = (m_pBottom != NULL);
m_targetLeft.angle = m_leftAngle;
m_targetLeft.distance = m_leftDistance;
m_targetLeft.valid = !m_leftClipped;
m_targetRight.angle = m_rightAngle;
m_targetRight.distance = m_rightDistance;
m_targetRight.valid = !m_rightClipped;
} else {
m_targetCenter.valid = false;
m_targetTop.valid = false;
m_targetBottom.valid = false;
m_targetLeft.valid = false;
m_targetRight.valid = false;
}
}
if (DriverStation::GetInstance()->GetEnhancedIO().GetDigital(3)) {
SaveImages();
}
}
// no thrashing!
Wait(0.10);
}
}
void CDialogCCD::OnBnClickedGetTemplateManu()
{
if (GetImage(&g_image) == false)
{
return;
}
CTemplateViewDlg _dlg(&g_image, FALSE, this);
_dlg.DoModal();
}
void IdeIconDes::Save()
{
if(format == 1) {
for(int i = 0; i < GetCount(); i++) {
Image m = GetImage(i);
Point p = m.Get2ndSpot();
if(m.GetKind() == IMAGE_ALPHA || p.x || p.y) {
if(PromptYesNo("Legacy file format does not support images "
"with full alpha channel or 2nd hotspot - "
"the information would be lost.&"
"Do you wish to convert the file to the new format?")) {
format = 0;
}
break;
}
}
}
StoreToGlobal(*this, "icondes-ctrl");
Array<ImlImage> m;
VectorMap<Size, Image> exp;
String folder = GetFileFolder(filename);
for(int i = 0; i < GetCount(); i++) {
ImlImage& c = m.Add();
c.name = GetName(i);
c.image = GetImage(i);
c.exp = GetExport(i);
if(c.exp) {
Size sz = c.image.GetSize();
exp.GetAdd(sz) = c.image;
PNGEncoder png;
SaveChangedFile(AppendFileName(folder, String().Cat() << "icon" << sz.cx << 'x' << sz.cy << ".png"),
png.SaveString(c.image));
}
}
String d = SaveIml(m, format);
if(!SaveChangedFileFinish(filename, d))
return;
filetime = FileGetTime(filename);
if(exp.GetCount())
SaveChangedFile(AppendFileName(folder, "icon.ico"), WriteIcon(exp.GetValues()));
}
/*****************************************************************************
* FUNCTION
* mmi_vrsdscut_del_tag_confirm
* DESCRIPTION
* This function is just for template.
* PARAMETERS
* void
* a(?) [IN/OUT] First variable, used as returns
* b(?) [IN] Second variable
* RETURNS
* the description of return value, if any.(?)
*****************************************************************************/
void mmi_vrsdscut_del_tag_confirm(void)
{
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
mmi_display_popup_confirm(
(UI_string_type)GetString(STR_GLOBAL_YES),
(PU8)GetImage(IMG_GLOBAL_YES),
(UI_string_type)GetString(STR_GLOBAL_NO),
(PU8)GetImage(IMG_GLOBAL_NO),
(UI_string_type)GetString(STR_ID_VRSD_DELETE_TAG_QUESTION),
MMI_EVENT_QUERY);
SetLeftSoftkeyFunction(mmi_vrsdscut_del_tag, KEY_EVENT_UP);
SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
}
/* ************************************************************* */
void ChangeDumpVar ()
/*
*
*
*************************************************************** */
{
Image *image;
image = GetImage("rho");
image->logscale = YES;
}
/*
Trasnfers the image or cancels the transfer depending on the state of the
TWAIN system
*/
void CTwain::TransferImage()
{
TW_IMAGEINFO info;
BOOL bContinue = TRUE;
int nScanStatus = 0; //扫描结束时状态，1--正常扫描结束
TRACE("********** TransferImage ************\n");
while(bContinue)
{
if (GetImageInfo(info) && _bTwainContinue) //GetImageInfo(info)
{
int permission;
permission = ShouldTransfer(info);
switch(permission)
{
case TWCPP_CANCELTHIS:
TRACE("************ TransferImage--> TWCPP_CANCELTHIS. 1 ************\n");
bContinue=EndTransfer();
nScanStatus = -1;
TRACE("************ TransferImage--> TWCPP_CANCELTHIS.2 ************\n");
break;
case TWCPP_CANCELALL:
TRACE("************ TransferImage--> TWCPP_CANCELALL. 1 ************\n");
CancelTransfer();
bContinue=FALSE;
nScanStatus = -2;
TRACE("************ TransferImage--> TWCPP_CANCELALL. 2 ************\n");
break;
case TWCPP_DOTRANSFER:
TRACE("********** TransferImage --> TWCPP_DOTRANSFER ************\n");
bContinue=GetImage(info);
if (!_bHasNextPic)
nScanStatus = 1;
else
nScanStatus = 2;
break;
default:
TRACE("************ TransferImage--> default. ************\n");
bContinue = FALSE;
nScanStatus = -3;
break;
}
}
else
{
TRACE("************ TransferImage --> GetImageInfo failed or m_bContinue = false *************\n");
nScanStatus = -4;
EndTransfer();
bContinue = FALSE;
}
}
TRACE("******* 扫描完成 ***********\n");
ScanDone(nScanStatus);
}
QByteArray *DcRawQT::GetImage(QString filename)
{
QStringList args;
args += "dcrawqt";
args += "-T";
args += "-c";
return GetImage(filename, args);
}
QByteArray *DcRawQT::GetImage(QString filename, QStringList args)
{
int argc;
char **argv;
args += filename;
argc = BuildCommandLine(args, &argv);
return GetImage(argc, argv);
}
QImage *ResourceController::GetTileset()
{
if(levelProperties.GetTilesetID() == 0)
return NULL;
Image *tempImage = GetImage(levelProperties.GetTilesetID());
if(tempImage)
return tempImage->GetImage();
else
return NULL;
}
BOOL CRemoteDoc::OnSaveDocument(LPCTSTR lpszPathName)
{
try {
ImageIOManager<pixel_type> &imageio = ImageIOManager<pixel_type>::instance();
imageio.write(lpszPathName, GetImage());
return true;
}catch(rss::Exception &) {
return false;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAvatarImagePanel::SetPlayer( C_BasePlayer *pPlayer )
{
if ( GetImage() )
{
((CAvatarImage*)GetImage())->ClearAvatarSteamID();
}
if ( pPlayer && steamapicontext->SteamUtils() )
{
int iIndex = pPlayer->entindex();
player_info_t pi;
if ( engine->GetPlayerInfo(iIndex, &pi) )
{
if ( pi.friendsID )
{
CSteamID steamIDForPlayer( pi.friendsID, 1, steamapicontext->SteamUtils()->GetConnectedUniverse(), k_EAccountTypeIndividual );
if ( !GetImage() )
{
CAvatarImage *pImage = new CAvatarImage();
SetImage( pImage );
}
((CAvatarImage*)GetImage())->SetAvatarSteamID( steamIDForPlayer );
// Indent the image. These are deliberately non-resolution-scaling.
int iIndent = 2;
GetImage()->SetPos( iIndent, iIndent );
GetImage()->SetSize( GetWide()-(iIndent*2), GetTall()-(iIndent*2) );
}
}
}
}
// OutputToStream()
// Outputs an ImageData instance as ASCII text to the stream provided.
void ImageData::OutputToStream( ostream &out ) {
out << " Filename: \"" << GetFilename() << "\"" << endl;
out << " File Format: " << GetFileFormat() << "; \"" << ImageFileFormatStrings[ GetFileFormat() ] << "\"" << endl;
out << " File Size: " << GetFileSize() << " bytes " << endl;
out << endl;
out << " File Data:" << endl;
out << " Bits Per Pixel: " << GetBitsPerPixel() << endl;
out << " Compression: " << GetCompression() << "; \"" << ImageCompressionModeStrings[ GetCompression() ] << "\"" << endl;
out << " DPI X/Y: " << GetDPIX() << "/" << GetDPIY() << endl;
out << " Pixel Aspect Ration: " << GetPixelAspectNum() << "/" << GetPixelAspectDenom() << endl;
out << " Gamma Correction: " << GetGammaNum() << "/" << GetGammaDenom() << endl;
out << " Thumbnail: ";
if( GetThumbnail() == NULL )
out << "No" << endl;
else
out << "Yes" << endl;
out << endl;
out << " Creator Data:" << endl;
out << " Author: \"" << GetAuthor() << "\"" << endl;
out << " Creator Program: \"" << GetCreator() << "\"" << endl;
out << " Creator Version: " << GetCreatorVersion() << "." << GetCreatorRevision() << GetCreatorSubRev() << endl;
out << " Comment: \"" << GetComment() << "\"" << endl;
out << " Job Name: \"" << GetJobName() << "\"" << endl;
out << " Job Time: " << GetJobTime()[0] << ":" << GetJobTime()[1] << ":" << GetJobTime()[2] << endl;
out << " Date Stamp: " << GetDateStamp()[0] << "/" << GetDateStamp()[1] << "/" << GetDateStamp()[2] << " "
<< GetDateStamp()[3] << ":" << GetDateStamp()[4] << ":" << GetDateStamp()[5] << endl;
out << endl;
out << " Image Data:" << endl;
out << " Width: " << GetImage()->GetWidth() << endl;
out << " Height: " << GetImage()->GetHeight() << endl;
out << " Type: " << GetImage()->GetType() << "; \"" << ImageTypeStrings[ GetImage()->GetType() ] << "\"" << endl;
out << " Num Registers: ";
if( GetImage()->GetType() == IMAGE_INDEXED )
out << GetImage()->GetNumRegisters() << endl;
else
out << "N/A" << endl;
}
BOOL Document_LoadImage(LPSTR lpFilePath)
{
static BYTE ImageCode[ 1024 * 256 ];// 存放图组压缩数据
static BYTE TileImage[ 32 * 15 ];// 存放图块数据
DWORD dwImageCount = 0;
DWORD dwLen = 0;
HBITMAP hBitmap1x = NULL;
HBITMAP hBitmap2x = NULL;
HBITMAP hBitmapOld = NULL;
DWORD i = 0;
FILE *fpGop = NULL;
if (lpFilePath == NULL)
{
return FALSE;
}
fpGop = fopen(lpFilePath, "rb");
if (fpGop == NULL)
{
return FALSE;
}
// 图组数据的长度
fread(&dwLen, sizeof(DWORD), 1, fpGop);
fread(ImageCode, dwLen, 1, fpGop);
// 创建图块，放大1倍
g_dwImageCount = ((WORD*)ImageCode)[ 0 ] - 1;
for (i = 0; i < g_dwImageCount; i++)
{
GetImage(ImageCode, i, TileImage, 32 * 15);
hBitmap1x = CreateBitmapFrom8Bits(TileImage, 32, 15, g_Palette);
hBitmap2x = ZoomIn(hBitmap1x, 2);
hBitmapOld = (HBITMAP)::SelectObject(g_hDCTileImage[ i ], hBitmap2x);
::DeleteObject(hBitmap1x);
::DeleteObject(hBitmapOld);
// 迷你地图用的
::BitBlt(g_hDCMiniTileImage[ i ], 0, 0, 1, 1, g_hDCTileImage[ i ], 32, 15, SRCCOPY);
}
return TRUE;
}
JBoolean
JXImageSelection::GetImage
(
const Atom selectionName,
const Time time,
JXDisplay* display,
JXImage** image,
const JBoolean allowApproxColors
)
{
return GetImage(display->GetSelectionManager(), selectionName, time,
display->GetColormap(), image, allowApproxColors);
}
