//------------------------------------------------------------------------------ void CNetscapeStatusBar::SetPercentDone(const int32 nPercent) { // Destroying the context in response to the window being destroyed // sometimes calls this, so we need to check that the window // still exists or we die. if (!m_hWnd) return; if( m_nDone != nPercent ) { if( m_iAnimRef && (nPercent == 0) ) { m_nDone = -1; } else { m_nDone = nPercent; } DrawProgressBar(); if( m_nDone >= 100 ) { // // Ensure progress never sits on 100% i.e., the back end might never // reset progress to 0 after specifying 100. // m_nDone = m_iAnimRef ? -1 : 0; DrawProgressBar(); } } }
void CHud::DrawDamageBar(LPDIRECT3DDEVICE9 pd3dDevice, const SPlayer* player, int x, int y, int segmentWidth){ float dmg = player->fCurrDamage; int width = segmentWidth * 3 / 4; std::stringstream ss; if (player->nLives > 0){ int div = (int) dmg / 100; for (int k = max(0,div-1); k <= div; k++){ dmg = player->fCurrDamage - 100.f * k; bool bDrawBack = (div == 0); DrawProgressBar(pd3dDevice, x, y, 16, width, min(dmg, 100.f) / 100.f, // percent SColor(153,max(0,255 - (51 * k)),0), //color bDrawBack); } ss << (int) player->fCurrDamage << "%"; } else { // Dead DrawProgressBar(pd3dDevice, x, y, 16, width, 1.f, // percent SColor(103, 103, 103), //color (gray) true); ss << "DEAD"; } // Write health amount over bar DrawHUDText(m_BigFont, ss.str().c_str(), x, y - 12, 42, width, DT_CENTER | DT_VCENTER, SColor(255,255,255)); }
// Window proc for gauge LRESULT APIENTRY GaugeWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) { DWORD dwStyle; RECT rect; switch (msg) { case WM_NCCREATE: dwStyle = GetWindowLong(hWnd, GWL_STYLE); SetWindowLong(hWnd, GWL_STYLE, dwStyle | WS_BORDER); return TRUE; case WM_CREATE: // Figure out the maximum number of bars that can be displayed GetClientRect(hWnd, &rect); dlgInfo.nBars = 0; dlgInfo.nMaxBars = (rect.right - rect.left - 2 * BAR_MARGIN + BAR_SPACING) / (BAR_WIDTH + BAR_SPACING); // Size the gauge to exactly fit the maximum number of bars SizeToFitGauge(hWnd); return TRUE; case WM_NCPAINT: DrawGaugeBorder(hWnd); return TRUE; case WM_PAINT: DrawProgressBar(hWnd); return TRUE; } return DefWindowProc(hWnd, msg, wParam, lParam); }
void UpdateVolumeBar(char vol, char old_vol){ //Use the progressbar element to show the volume ProgressBar1.Position = vol; DrawProgressBar(&ProgressBar1); }
void CHud::DrawMyPlayerInfo(LPDIRECT3DDEVICE9 pd3dDevice){ int segmentWidth = m_nWidth / 2; int segmentHeight = m_nHeight / 5; // Draw Damage Bar DrawDamageBar(pd3dDevice, pMyPlayer, m_nX + segmentWidth / 8, // x segmentHeight / 4, // y segmentWidth); // width // Draw Charge Bar std::stringstream ss; ss << "Charge"; DrawProgressBar(pd3dDevice, m_nX + segmentWidth / 8, segmentHeight / 2, 16, segmentWidth * 3 / 4, pMyPlayer->fCurrCharge / pMyPlayer->fMaxCharge, SColor(0,0,255) , true); DrawHUDText(m_BigFont, ss.str().c_str(), m_nX + segmentWidth / 8, (segmentHeight / 2) - 12, 42, segmentWidth * 3 / 4, DT_CENTER | DT_VCENTER, SColor(255,255,255)); // Draw Lives DrawLiveIcons(pMyPlayer->nLives, m_nX + (segmentWidth / 8), // x m_nY + segmentHeight * 3 / 4, // y segmentWidth); }
//------------------------------------------------------------------------------ void CNetscapeStatusBar::OnPaint() { #if defined(MSVC4) CStatusBar::OnPaint(); CClientDC dc(this); #else CPaintDC dc(this); // Do not call CStatusBar::OnPaint()! CNetscapeStatusBarBase::DoPaint( &dc ); #endif // MSVC4 // // Special per mode painting // switch( m_enStatBarMode ) { case eSBM_Panes: { // Nothing to do break; } case eSBM_Simple: default: { // Nothing to do break; } } DrawSecureStatus(dc.m_hDC); DrawSignedStatus(dc.m_hDC); DrawProgressBar(); }
// Window proc for Download gauge BOOL CALLBACK GaugeDownloadWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) { DWORD dwStyle; RECT rect; switch(msg) { case WM_NCCREATE: dwStyle = GetWindowLong(hWnd, GWL_STYLE); SetWindowLong(hWnd, GWL_STYLE, dwStyle | WS_BORDER); return(TRUE); case WM_CREATE: // Figure out the maximum number of bars that can be displayed GetClientRect(hWnd, &rect); dlgInfo.nFileBars = 0; dlgInfo.nMaxFileBars = (rect.right - rect.left - 2 * BAR_LIBXPNET_MARGIN + BAR_LIBXPNET_SPACING) / (BAR_LIBXPNET_WIDTH + BAR_LIBXPNET_SPACING); // Size the gauge to exactly fit the maximum number of bars SizeToFitGauge(hWnd, dlgInfo.nMaxFileBars); return(FALSE); case WM_NCPAINT: DrawGaugeBorder(hWnd); return(FALSE); case WM_PAINT: DrawProgressBar(hWnd, dlgInfo.nFileBars); return(FALSE); } return(DefWindowProc(hWnd, msg, wParam, lParam)); }
// Processes a sound file to include the response in the recorder // track. The response is interpolated with another response to // suggest the perception of movement from one location to the other RecorderTrack* RecorderTrack::Process(RecorderTrack* const other, SoundFile* const sound_file) const { RecorderTrack* result = new RecorderTrack(); RecorderTrack& _result = *result; const RecorderTrack& _this = *this; const RecorderTrack& _other = *other; const unsigned int sound_length = sound_file->sample_length; const float flt_samples = 1.0f / (float) sound_length; const unsigned int len = (std::max)( real_length,other->real_length); const unsigned int first = (std::min)( first_sample,other->first_sample); for( unsigned int i = 0; i < sound_length; i ++ ) { const float i1 = i * flt_samples; const float i2 = 1.0f - i1; const float sfs = sound_file->data[i]; int index = i + sound_file->offset + first; for ( unsigned int j = first; j < len; j ++ ) { const float p = i2 * _this[j] + i1 * _other[j]; _result[index++] += sfs * p; } DrawProgressBar(i,sound_length); } return result; }
void DrawRenderProgressBar() { int rp = renderImage.GetNumRenderedPixels(); int np = renderImage.GetWidth() * renderImage.GetHeight(); if ( rp >= np ) return; float done = (float) rp / (float) np; DrawProgressBar(done); }
VOID ProgressSetStepCount( IN PPROGRESSBAR Bar, IN ULONG StepCount) { Bar->CurrentStep = 0; Bar->StepCount = StepCount; Bar->Progress = 0; Bar->Pos = 0; DrawProgressBar(Bar); }
void GlutDisplay() { switch ( viewMode ) { case VIEWMODE_OPENGL: if ( dofImage ) { if ( dofDrawCount < MAX_DOF_DRAW ) { DrawScene(); glReadPixels( 0, 0, camera.imgWidth, camera.imgHeight, GL_RGB, GL_UNSIGNED_BYTE, dofBuffer ); for ( int i=0; i<camera.imgWidth*camera.imgHeight; i++ ) { dofImage[i] = (dofImage[i]*dofDrawCount + dofBuffer[i].ToColor())/(dofDrawCount+1); } dofDrawCount++; } glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT ); glDrawPixels( camera.imgWidth, camera.imgHeight, GL_RGB, GL_FLOAT, dofImage ); if ( dofDrawCount < MAX_DOF_DRAW ) { DrawProgressBar(float(dofDrawCount)/MAX_DOF_DRAW); glutPostRedisplay(); } } else { DrawScene(); } break; case VIEWMODE_IMAGE: glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT ); glDrawPixels( renderImage.GetWidth(), renderImage.GetHeight(), GL_RGB, GL_UNSIGNED_BYTE, renderImage.GetPixels() ); DrawRenderProgressBar(); break; case VIEWMODE_Z: glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT ); if ( ! renderImage.GetZBufferImage() ) renderImage.ComputeZBufferImage(); glDrawPixels( renderImage.GetWidth(), renderImage.GetHeight(), GL_LUMINANCE, GL_UNSIGNED_BYTE, renderImage.GetZBufferImage() ); break; case VIEWMODE_SAMPLECOUNT: glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT ); if ( ! renderImage.GetSampleCountImage() ) renderImage.ComputeSampleCountImage(); glDrawPixels( renderImage.GetWidth(), renderImage.GetHeight(), GL_LUMINANCE, GL_UNSIGNED_BYTE, renderImage.GetSampleCountImage() ); break; case VIEWMODE_IRRADCOMP: glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT ); if ( renderImage.GetIrradianceComputationImage() ) { glDrawPixels( renderImage.GetWidth(), renderImage.GetHeight(), GL_LUMINANCE, GL_UNSIGNED_BYTE, renderImage.GetIrradianceComputationImage() ); } break; } glutSwapBuffers(); }
void CDownloadMonitorDlg::DoPaint(CDC& dc) { CRect rc; m_wndProgress.GetWindowRect( &rc ); ScreenToClient( &rc ); DrawProgressBar( &dc, &rc ); m_wndGraph.GetWindowRect( &rc ); ScreenToClient( &rc ); dc.Draw3dRect( &rc, 0, 0 ); rc.DeflateRect( 1, 1 ); m_pGraph->BufferedPaint( &dc, &rc ); }
// Processes a sound file to include the response in the recorder // track. The response is not interpolated with a successive response RecorderTrack* RecorderTrack::Process(SoundFile* const sound_file) const { RecorderTrack* result = new RecorderTrack(); RecorderTrack& _result = *result; const RecorderTrack& _this = *this; const unsigned int len = this->real_length; const unsigned int sound_length = sound_file->sample_length; for ( unsigned int i = 0; i < sound_length; ++ i ) { const float sfs = sound_file->data[i]; int index = i + sound_file->offset + first_sample; for ( unsigned int j = first_sample; j < len; ++ j ) { _result[index++] += sfs * _this[j]; } DrawProgressBar(i,sound_length); } return result; }
void ThemeManager::DrawListProgress(HDC hdc, const LPRECT rect, ListProgressType type) { auto& item = list_progress_[type]; // Solid if (item.type == L"solid") { HBRUSH hbrSolid = CreateSolidBrush(item.value[0]); FillRect(hdc, rect, hbrSolid); DeleteObject(hbrSolid); // Gradient } else if (item.type == L"gradient") { GradientRect(hdc, rect, item.value[0], item.value[1], item.value[2] > 0); // Progress bar } else if (item.type == L"progress") { DrawProgressBar(hdc, rect, item.value[0], item.value[1], item.value[2]); } }
// Checks if devices are available, prints name of device being detected for slow init devices void populateDeviceAvailability() { if(PAD_ButtonsHeld(0) & PAD_BUTTON_B) { deviceHandler_setAllDevicesAvailable(); return; } uiDrawObj_t *msgBox = DrawPublish(DrawProgressBar(true, 0, "Detecting devices ...\nThis can be skipped by holding B next time")); int i; for(i = 0; i < MAX_DEVICES; i++) { if(allDevices[i] != NULL && !deviceHandler_getDeviceAvailable(allDevices[i])) { print_gecko("Checking device availability for device %s\r\n", allDevices[i]->deviceName); deviceHandler_setDeviceAvailable(allDevices[i], allDevices[i]->test()); } if(PAD_ButtonsHeld(0) & PAD_BUTTON_B) { deviceHandler_setAllDevicesAvailable(); break; } } DrawDispose(msgBox); }
void CSListCtrl::DrawItem(int nItem, int nSubItem, CDC* pDC) { //Color COLORREF crText = m_crWindowText; COLORREF crBkgnd = m_crWindow; GetDrawColors(nItem, nSubItem, crText, crBkgnd); //Rectangle CRect rect; GetSubItemRect(nItem, nSubItem, LVIR_BOUNDS, rect); //Paint background CRect rcTemp = rect; rcTemp.bottom -= 1; pDC->FillSolidRect(&rcTemp, crBkgnd); //Sub Item data CListSubItemData* pSubItemData = GetSubItemData(nItem, nSubItem); ASSERT(pSubItemData); //1. Draw Check Box if(pSubItemData->m_nCheckState != SHC_NONE_CHECK_BOX) { DrawCheckBox(nItem, nSubItem, pDC); } //2. Draw Image if(pSubItemData->m_pListImage != NULL) { DrawImage(nItem, nSubItem, pDC); } //3. Draw Text or Progress if(pSubItemData->m_pListPrgsBar != NULL) { DrawProgressBar(nItem, nSubItem, pDC); } else { DrawText(nItem, nSubItem, pDC); } }
int HUD_Redraw( float flTime, int state ) { switch( state ) { case CL_LOADING: DrawProgressBar(); break; case CL_ACTIVE: gHUD.Redraw( flTime ); break; case CL_PAUSED: gHUD.Redraw( flTime ); DrawPause(); break; case CL_CHANGELEVEL: DrawImageBar( 100, "m_loading" ); break; } return 1; }
void CStatusLineCtrl::OnPaint(wxPaintEvent&) { wxPaintDC dc(this); wxRect rect = GetRect(); int refresh = 0; if (!m_data.IsOk() || rect.GetWidth() != m_data.GetWidth() || rect.GetHeight() != m_data.GetHeight()) { m_mdc.reset(); m_data = wxBitmap(rect.GetWidth(), rect.GetHeight()); m_mdc = std::make_unique<wxMemoryDC>(m_data); // Use same layout direction as the DC which bitmap is drawn on. // This avoids problem with mirrored characters on RTL locales. m_mdc->SetLayoutDirection(dc.GetLayoutDirection()); refresh = 31; } fz::duration elapsed; int left = -1; wxFileOffset rate; wxString bytes_and_rate; int bar_split = -1; int permill = -1; if (status_.empty()) { if (m_previousStatusText != m_statusText) { // Clear background m_mdc->SetFont(GetFont()); m_mdc->SetPen(GetBackgroundColour()); m_mdc->SetBrush(GetBackgroundColour()); m_mdc->SetTextForeground(GetForegroundColour()); m_mdc->DrawRectangle(0, 0, rect.GetWidth(), rect.GetHeight()); wxCoord h = (rect.GetHeight() - m_textHeight) / 2; m_mdc->DrawText(m_statusText, 50, h); m_previousStatusText = m_statusText; refresh = 0; } } else { if (!m_previousStatusText.empty()) { m_previousStatusText.clear(); refresh = 31; } int elapsed_milli_seconds = 0; if (!status_.started.empty()) { elapsed = fz::datetime::now() - status_.started; elapsed_milli_seconds = static_cast<int>(elapsed.get_milliseconds()); // Assume it doesn't overflow } if (elapsed_milli_seconds / 1000 != m_last_elapsed_seconds) { refresh |= 1; m_last_elapsed_seconds = elapsed_milli_seconds / 1000; } if (COptions::Get()->GetOptionVal(OPTION_SPEED_DISPLAY)) rate = GetMomentarySpeed(); else rate = GetAverageSpeed(elapsed_milli_seconds); if (status_.totalSize > 0 && elapsed_milli_seconds >= 1000 && rate > 0) { wxFileOffset r = status_.totalSize - status_.currentOffset; left = r / rate + 1; if (r) ++left; if (left < 0) left = 0; } if (m_last_left != left) { refresh |= 2; m_last_left = left; } const wxString bytestr = CSizeFormat::Format(status_.currentOffset, true, CSizeFormat::bytes, COptions::Get()->GetOptionVal(OPTION_SIZE_USETHOUSANDSEP) != 0, 0); if (elapsed_milli_seconds >= 1000 && rate > -1) { CSizeFormat::_format format = static_cast<CSizeFormat::_format>(COptions::Get()->GetOptionVal(OPTION_SIZE_FORMAT)); if (format == CSizeFormat::bytes) format = CSizeFormat::iec; const wxString ratestr = CSizeFormat::Format(rate, true, format, COptions::Get()->GetOptionVal(OPTION_SIZE_USETHOUSANDSEP) != 0, COptions::Get()->GetOptionVal(OPTION_SIZE_DECIMALPLACES)); bytes_and_rate.Printf(_("%s (%s/s)"), bytestr, ratestr ); } else bytes_and_rate.Printf(_("%s (? B/s)"), bytestr); if (m_last_bytes_and_rate != bytes_and_rate) { refresh |= 8; m_last_bytes_and_rate = bytes_and_rate; } if (status_.totalSize > 0) { bar_split = static_cast<int>(status_.currentOffset * (PROGRESSBAR_WIDTH - 2) / status_.totalSize); if (bar_split > (PROGRESSBAR_WIDTH - 2)) bar_split = PROGRESSBAR_WIDTH - 2; if (status_.currentOffset > status_.totalSize) permill = 1001; else permill = static_cast<int>(status_.currentOffset * 1000 / status_.totalSize); } if (m_last_bar_split != bar_split || m_last_permill != permill) { refresh |= 4; m_last_bar_split = bar_split; m_last_permill = permill; } } if (refresh) { m_mdc->SetFont(GetFont()); m_mdc->SetPen(GetBackgroundColour()); m_mdc->SetBrush(GetBackgroundColour()); m_mdc->SetTextForeground(GetForegroundColour()); // Get character height so that we can center the text vertically. wxCoord h = (rect.GetHeight() - m_textHeight) / 2; if (refresh & 1) { m_mdc->DrawRectangle(0, 0, m_fieldOffsets[0], rect.GetHeight()); DrawRightAlignedText(*m_mdc, wxTimeSpan::Milliseconds(elapsed.get_milliseconds()).Format(_("%H:%M:%S elapsed")), m_fieldOffsets[0], h); } if (refresh & 2) { m_mdc->DrawRectangle(m_fieldOffsets[0], 0, m_fieldOffsets[1] - m_fieldOffsets[0], rect.GetHeight()); if (left != -1) { wxTimeSpan timeLeft(0, 0, left); DrawRightAlignedText(*m_mdc, timeLeft.Format(_("%H:%M:%S left")), m_fieldOffsets[1], h); } else DrawRightAlignedText(*m_mdc, _("--:--:-- left"), m_fieldOffsets[1], h); } if (refresh & 8) { m_mdc->DrawRectangle(m_fieldOffsets[3], 0, rect.GetWidth() - m_fieldOffsets[3], rect.GetHeight()); m_mdc->DrawText(bytes_and_rate, m_fieldOffsets[3], h); } if (refresh & 16) { m_mdc->DrawRectangle(m_fieldOffsets[1], 0, m_fieldOffsets[2] - m_fieldOffsets[1], rect.GetHeight()); } if (refresh & 4) { m_mdc->DrawRectangle(m_fieldOffsets[2], 0, m_fieldOffsets[3] - m_fieldOffsets[2], rect.GetHeight()); if (bar_split != -1) DrawProgressBar(*m_mdc, m_fieldOffsets[2], 1, rect.GetHeight() - 2, bar_split, permill); } } dc.Blit(0, 0, rect.GetWidth(), rect.GetHeight(), m_mdc.get(), 0, 0); }
void pawsProgressBar::Draw() { ClipToParent(false); int alpha = 255; int Time = csGetTicks(); int primary_r; int primary_g; int primary_b; if(parent && !parent->GetBackground().IsEmpty() && parent->isFadeEnabled() && parent->GetMaxAlpha() != parent->GetMinAlpha()) { alpha = (int) (255 - (parent->GetMinAlpha() + (parent->GetMaxAlpha()-parent->GetMinAlpha()) * parent->GetFadeVal() * 0.010)); } DrawBackground(); if( flashLevel > 0 ) { if( ( (flashLow && percent<flashLevel) || (!flashLow && percent>flashLevel) ) ) { if( flashLastTime+flashRate <= Time ) { On=!On; flashLastTime = Time; } } else { On=true; } } if( warnLevel > 0 && ( (warnLow && percent < warnLevel) || (!warnLow && percent >warnLevel) ) ) { if( dangerLevel > 0 && ( (dangerLow && percent < dangerLevel) || (!dangerLow && percent >dangerLevel) ) ) { primary_r = danger_r; primary_g = danger_g; primary_b = danger_b; } else { primary_r = warn_r; primary_g = warn_g; primary_b = warn_b; } } else { primary_r = start_r; primary_g = start_g; primary_b = start_b; } if( On ) { DrawProgressBar(screenFrame, PawsManager::GetSingleton().GetGraphics3D(), percent, primary_r, primary_g, primary_b, diff_r, diff_g, diff_b, alpha); } else { DrawProgressBar(screenFrame, PawsManager::GetSingleton().GetGraphics3D(), percent, flash_r, flash_g, flash_b, flash_r, flash_g, flash_b, alpha); } DrawChildren(); DrawMask(); }
int patch_gcm(file_handle *file, ExecutableFile *filesToPatch, int numToPatch, int multiDol) { int i, num_patched = 0; // If the current device isn't SD Gecko, init SD Gecko Slot A or B to write patches. if(deviceHandler_initial != &initial_SD0 && deviceHandler_initial != &initial_SD1) { deviceHandler_setStatEnabled(0); if(deviceHandler_FAT_init(&initial_SD0)) { savePatchDevice = 0; } else if(deviceHandler_FAT_init(&initial_SD1)) { savePatchDevice = 1; } deviceHandler_setStatEnabled(1); } // Already using SD Gecko if(deviceHandler_initial == &initial_SD0) savePatchDevice = 0; else if(deviceHandler_initial == &initial_SD1) savePatchDevice = 1; if(savePatchDevice == -1) { DrawFrameStart(); DrawMessageBox(D_FAIL, "No writable device present\nA SD Gecko must be inserted in\n order to utilise patches for this game."); DrawFrameFinish(); sleep(5); return 0; } char patchFileName[256]; char patchDirName[256]; char patchBaseDirName[256]; char gameID[8]; memset(&gameID, 0, 8); memset(&patchDirName, 0, 256); memset(&patchBaseDirName, 0, 256); strncpy((char*)&gameID, (char*)&GCMDisk, 4); sprintf(&patchDirName[0],"%s:/swiss_patches/%s",(savePatchDevice ? "sdb":"sda"), &gameID[0]); sprintf(&patchBaseDirName[0],"%s:/swiss_patches",(savePatchDevice ? "sdb":"sda")); print_gecko("Patch dir will be: %s if required\r\n", patchDirName); *(u32*)VAR_EXECD_OFFSET = 0xFFFFFFFF; // Go through all the possible files we think need patching.. for(i = 0; i < numToPatch; i++) { u32 patched = 0, crc32 = 0; sprintf(txtbuffer, "Patching File %i/%i",i+1,numToPatch); DrawFrameStart(); DrawProgressBar((int)(((float)(i+1)/(float)numToPatch)*100), txtbuffer); DrawFrameFinish(); // Round up to 32 bytes if(filesToPatch[i].size % 0x20) { filesToPatch[i].size += (0x20-(filesToPatch[i].size%0x20)); } if(filesToPatch[i].size > 8*1024*1024) { print_gecko("Skipping %s %iKB too large\r\n", filesToPatch[i].name, filesToPatch[i].size/1024); continue; } print_gecko("Checking %s %iKb\r\n", filesToPatch[i].name, filesToPatch[i].size/1024); if(strstr(filesToPatch[i].name, "execD.")) { *(u32*)VAR_EXECD_OFFSET = filesToPatch[i].offset; } if(strstr(filesToPatch[i].name, "iwanagaD.dol") || strstr(filesToPatch[i].name, "switcherD.dol")) { continue; // skip unused PSO files } int sizeToRead = filesToPatch[i].size; u8 *buffer = (u8*)memalign(32, sizeToRead); deviceHandler_seekFile(file,filesToPatch[i].offset, DEVICE_HANDLER_SEEK_SET); if(deviceHandler_readFile(file,buffer,sizeToRead)!= sizeToRead) { DrawFrameStart(); DrawMessageBox(D_FAIL, "Failed to read!"); DrawFrameFinish(); sleep(5); return 0; } if(curDevice != DVD_DISC) { u32 ret = Patch_DVDLowLevelRead(buffer, sizeToRead, filesToPatch[i].type); if(READ_PATCHED_ALL != ret) { DrawFrameStart(); DrawMessageBox(D_FAIL, "Failed to find necessary functions for patching!"); DrawFrameFinish(); sleep(5); } else patched += 1; } if(swissSettings.debugUSB && usb_isgeckoalive(1) && !swissSettings.wiirdDebug) { patched += Patch_Fwrite(buffer, sizeToRead); } if(swissSettings.wiirdDebug || getEnabledCheatsSize() > 0) { Patch_CheatsHook(buffer, sizeToRead, filesToPatch[i].type); } if(curDevice == DVD_DISC && is_gamecube()) { patched += Patch_DVDLowLevelReadForDVD(buffer, sizeToRead, filesToPatch[i].type); patched += Patch_DVDReset(buffer, sizeToRead); } patched += Patch_VidMode(buffer, sizeToRead, filesToPatch[i].type); patched += Patch_FontEnc(buffer, sizeToRead); if(swissSettings.forceWidescreen) Patch_WideAspect(buffer, sizeToRead, filesToPatch[i].type); if(swissSettings.forceAnisotropy) Patch_TexFilt(buffer, sizeToRead, filesToPatch[i].type); if(patched) { // File handle for a patch we might need to write FILE *patchFile = 0; memset(patchFileName, 0, 256); // Make a base patches dir if we don't have one already if(mkdir(&patchBaseDirName[0], 0777) != 0) { if(errno != EEXIST) { return -2; } } if(mkdir(&patchDirName[0], 0777) != 0) { if(errno != EEXIST) { return -2; } } sprintf(patchFileName, "%s/%i",patchDirName, num_patched); // Work out the crc32 crc32 = Crc32_ComputeBuf( 0, buffer, (u32) sizeToRead); // See if this file already exists, if it does, match crc patchFile = fopen( patchFileName, "rb" ); if(patchFile) { //print_gecko("Old Patch exists\r\n"); u32 oldCrc32 = 0; fseek(patchFile, 0L, SEEK_END); u32 file_size = ftell(patchFile); fseek(patchFile, file_size-4, SEEK_SET); fread(&oldCrc32, 1, 4, patchFile); if(oldCrc32 == crc32) { num_patched++; fclose(patchFile); free(buffer); print_gecko("CRC matched, no need to patch again\r\n"); continue; } else { remove(patchFileName); fclose(patchFile); print_gecko("CRC mismatch, writing patch again\r\n"); } } // Otherwise, write a file out for this game with the patched buffer inside. print_gecko("Writing patch file: %s %i bytes (disc offset %08X)\r\n", patchFileName, sizeToRead, filesToPatch[i].offset); patchFile = fopen(patchFileName, "wb"); fwrite(buffer, 1, sizeToRead, patchFile); u32 magic = SWISS_MAGIC; fwrite(&filesToPatch[i].offset, 1, 4, patchFile); fwrite(&filesToPatch[i].size, 1, 4, patchFile); fwrite(&magic, 1, 4, patchFile); fwrite(&crc32, 1, 4, patchFile); fclose(patchFile); num_patched++; } free(buffer); } return num_patched; }
/**************************************************************************** * Main ****************************************************************************/ int main () { // Setup defaults (if no config is found) memset(&swissSettings, 0 , sizeof(SwissSettings)); // Register all devices supported (order matters for boot devices) int i = 0; for(i = 0; i < MAX_DEVICES; i++) allDevices[i] = NULL; i = 0; allDevices[i++] = &__device_wkf; allDevices[i++] = &__device_wode; allDevices[i++] = &__device_sd_a; allDevices[i++] = &__device_sd_b; allDevices[i++] = &__device_card_a; allDevices[i++] = &__device_card_b; allDevices[i++] = &__device_dvd; allDevices[i++] = &__device_ide_a; allDevices[i++] = &__device_ide_b; allDevices[i++] = &__device_qoob; allDevices[i++] = &__device_smb; allDevices[i++] = &__device_sys; allDevices[i++] = &__device_usbgecko; allDevices[i++] = &__device_ftp; allDevices[i++] = &__device_fsp; allDevices[i++] = NULL; // Set current devices devices[DEVICE_CUR] = NULL; devices[DEVICE_DEST] = NULL; devices[DEVICE_TEMP] = NULL; devices[DEVICE_CONFIG] = NULL; devices[DEVICE_PATCHES] = NULL; Initialise(); // Sane defaults refreshSRAM(&swissSettings); swissSettings.debugUSB = 0; swissSettings.gameVMode = 0; // Auto video mode swissSettings.exiSpeed = 1; // 32MHz swissSettings.uiVMode = 0; // Auto UI mode swissSettings.aveCompat = 1; swissSettings.enableFileManagement = 0; needsDeviceChange = 1; needsRefresh = 1; //debugging stuff if(swissSettings.debugUSB) { if(usb_isgeckoalive(1)) { usb_flush(1); } print_gecko("Arena Size: %iKb\r\n",(SYS_GetArena1Hi()-SYS_GetArena1Lo())/1024); print_gecko("DVD Drive Present? %s\r\n",swissSettings.hasDVDDrive?"Yes":"No"); print_gecko("GIT Commit: %s\r\n", GITREVISION); print_gecko("GIT Revision: %s\r\n", GITVERSION); } // Go through all devices with FEAT_BOOT_DEVICE feature and set it as current if one is available for(i = 0; i < MAX_DEVICES; i++) { if(allDevices[i] != NULL && (allDevices[i]->features & FEAT_BOOT_DEVICE)) { print_gecko("Testing device %s\r\n", allDevices[i]->deviceName); if(allDevices[i]->test()) { deviceHandler_setDeviceAvailable(allDevices[i], true); devices[DEVICE_CUR] = allDevices[i]; break; } } } if(devices[DEVICE_CUR] != NULL) { print_gecko("Detected %s\r\n", devices[DEVICE_CUR]->deviceName); if(devices[DEVICE_CUR]->init(devices[DEVICE_CUR]->initial)) { if(devices[DEVICE_CUR]->features & FEAT_AUTOLOAD_DOL) { load_auto_dol(); } memcpy(&curFile, devices[DEVICE_CUR]->initial, sizeof(file_handle)); needsDeviceChange = 0; } } // Scan here since some devices would already be initialised (faster) populateDeviceAvailability(); // If there's no default config device, set it to the first writable device available if(swissSettings.configDeviceId == DEVICE_ID_UNK) { for(int i = 0; i < MAX_DEVICES; i++) { if(allDevices[i] != NULL && (allDevices[i]->features & FEAT_WRITE) && deviceHandler_getDeviceAvailable(allDevices[i])) { swissSettings.configDeviceId = allDevices[i]->deviceUniqueId; print_gecko("No default config device found, using [%s]\r\n", allDevices[i]->deviceName); syssramex* sramex = __SYS_LockSramEx(); sramex->__padding0 = swissSettings.configDeviceId; __SYS_UnlockSramEx(1); while(!__SYS_SyncSram()); break; } } } // Try to open up the config .ini in case it hasn't been opened already if(config_init()) { // TODO notification area this print_gecko("Loaded %i entries from the config file\r\n",config_get_count()); } if(swissSettings.initNetworkAtStart) { // Start up the BBA if it exists uiDrawObj_t *msgBox = DrawPublish(DrawProgressBar(true, 0, "Initialising Network")); init_network(); init_httpd_thread(); DrawDispose(msgBox); } // DVD Motor off setting; Always stop the drive if we only started it to read the ID out if((swissSettings.stopMotor && swissSettings.hasDVDDrive) || (swissSettings.hasDVDDrive == 2)) { dvd_motor_off(); } // Swiss video mode force GXRModeObj *forcedMode = getVideoModeFromSwissSetting(swissSettings.uiVMode); if((forcedMode != NULL) && (forcedMode != getVideoMode())) { setVideoMode(forcedMode); } while(1) { menu_loop(); } return 0; }
void CUploadTipCtrl::OnPaint(CDC* pDC, CUploadTransfer* pUpload) { CPoint pt( 0, 0 ); CSize sz( m_sz.cx, TIP_TEXTHEIGHT ); DrawText( pDC, &pt, m_pUploadFile->m_sName ); pt.y += TIP_TEXTHEIGHT; DrawText( pDC, &pt, m_sAddress ); pDC->SelectObject( &CoolInterface.m_fntNormal ); pt.y += TIP_TEXTHEIGHT; int nFlagIndex = Flags.GetFlagIndex( pUpload->m_sCountry ); if ( nFlagIndex >= 0 ) { Flags.Draw( nFlagIndex, pDC->GetSafeHdc(), pt.x, pt.y, CoolInterface.m_crTipBack ); pDC->ExcludeClipRect( pt.x, pt.y, pt.x + 16, pt.y + 16 ); } pt.x += 16 + 4; DrawText( pDC, &pt, pUpload->m_sCountryName ); pt.x -= 16 + 4; pt.y += 16; DrawRule( pDC, &pt ); CString strStatus, strSpeed, strText; CString strOf; LoadString( strOf, IDS_GENERAL_OF ); strSpeed.Format( _T("%s %s %s (%s)"), (LPCTSTR)Settings.SmartSpeed( pUpload->GetMeasuredSpeed() ), (LPCTSTR)strOf, (LPCTSTR)Settings.SmartSpeed( pUpload->m_nBandwidth ), (LPCTSTR)Settings.SmartSpeed( pUpload->GetMaxSpeed() ) ); int nQueue = UploadQueues.GetPosition( pUpload, FALSE ); if ( m_pUploadFile != pUpload->m_pBaseFile || pUpload->m_nState == upsNull ) { LoadString( strStatus, IDS_TIP_INACTIVE ); } else if ( nQueue == 0 ) { if ( pUpload->m_nState == upsQueued ) { LoadString( strText, IDS_TIP_NEXT ); strStatus.Format( _T("%s: %s"), (LPCTSTR)pUpload->m_pQueue->m_sName, (LPCTSTR)strText ); } else { LoadString( strText, IDS_TIP_ACTIVE ); strStatus.Format( _T("%s: %s"), (LPCTSTR)pUpload->m_pQueue->m_sName, (LPCTSTR)strText ); } } else if ( nQueue > 0 ) { strStatus.Format( _T("%s: %i %s %u"), (LPCTSTR)pUpload->m_pQueue->m_sName, nQueue, (LPCTSTR)strOf, pUpload->m_pQueue->GetQueuedCount() ); } else { LoadString( strStatus, IDS_TIP_ACTIVE ); } LoadString( strText, IDS_TIP_STATUS ); DrawText( pDC, &pt, strText ); DrawText( pDC, &pt, strStatus, 80 ); pt.y += TIP_TEXTHEIGHT; LoadString( strText, IDS_TIP_SPEED ); DrawText( pDC, &pt, strText ); DrawText( pDC, &pt, strSpeed, 80 ); pt.y += TIP_TEXTHEIGHT; LoadString( strText, IDS_TIP_USERAGENT ); DrawText( pDC, &pt, strText ); DrawText( pDC, &pt, pUpload->m_sUserAgent, 80 ); pt.y += TIP_TEXTHEIGHT; pt.y += TIP_GAP; DrawProgressBar( pDC, &pt, m_pUploadFile ); pt.y += TIP_GAP; CRect rc( pt.x, pt.y, m_sz.cx, pt.y + 40 ); pDC->Draw3dRect( &rc, CoolInterface.m_crTipBorder, CoolInterface.m_crTipBorder ); rc.DeflateRect( 1, 1 ); if ( m_pGraph) m_pGraph->BufferedPaint( pDC, &rc ); rc.InflateRect( 1, 1 ); pDC->ExcludeClipRect( &rc ); pt.y += 40; pt.y += TIP_GAP; if ( Settings.General.GUIMode != GUI_BASIC ) { if ( m_nHeaders != pUpload->m_pHeaderName.GetSize() ) { ShowImpl( true ); return; } for ( int nHeader = 0 ; nHeader < m_nHeaders ; nHeader++ ) { CString strName = pUpload->m_pHeaderName.GetAt( nHeader ) + _T(':'); CString strValue = pUpload->m_pHeaderValue.GetAt( nHeader ); DrawText( pDC, &pt, strName ); pt.x += m_nHeaderWidth; sz.cx -= m_nHeaderWidth; DrawText( pDC, &pt, strValue, &sz ); pt.x -= m_nHeaderWidth; sz.cx += m_nHeaderWidth; pt.y += TIP_TEXTHEIGHT; } } }
/* Initialise Video, PAD, DVD, Font */ void Initialise (void) { VIDEO_Init (); PAD_Init (); DVD_Init(); *(volatile unsigned long*)0xcc00643c = 0x00000000; //allow 32mhz exi bus // Disable IPL modchips to allow access to IPL ROM fonts ipl_set_config(6); usleep(1000); //wait for modchip to disable (overkill) __SYS_ReadROM(IPLInfo,256,0); // Read IPL tag // By default, let libOGC figure out the video mode GXRModeObj *vmode = VIDEO_GetPreferredMode(NULL); //Last mode used if(is_gamecube()) { // Gamecube, determine based on IPL int retPAD = 0, retCnt = 10000; while(retPAD <= 0 && retCnt >= 0) { retPAD = PAD_ScanPads(); usleep(100); retCnt--; } // L Trigger held down ignores the fact that there's a component cable plugged in. if(VIDEO_HaveComponentCable() && !(PAD_ButtonsDown(0) & PAD_TRIGGER_L)) { if(strstr(IPLInfo,"MPAL")!=NULL) { swissSettings.sramVideo = 2; vmode = &TVMpal480Prog; //Progressive 480p } else if((strstr(IPLInfo,"PAL")!=NULL)) { swissSettings.sramVideo = 1; vmode = &TVPal576ProgScale; //Progressive 576p } else { swissSettings.sramVideo = 0; vmode = &TVNtsc480Prog; //Progressive 480p } } else { //try to use the IPL region if(strstr(IPLInfo,"MPAL")!=NULL) { swissSettings.sramVideo = 2; vmode = &TVMpal480IntDf; //PAL-M } else if(strstr(IPLInfo,"PAL")!=NULL) { swissSettings.sramVideo = 1; vmode = &TVPal576IntDfScale; //PAL } else { swissSettings.sramVideo = 0; vmode = &TVNtsc480IntDf; //NTSC } } } setVideoMode(vmode); init_font(); DrawInit(); drive_version(&driveVersion[0]); swissSettings.hasDVDDrive = *(u32*)&driveVersion[0] ? 1 : 0; if(!driveVersion[0]) { // Reset DVD if there was a IPL replacement that hasn't done that for us yet uiDrawObj_t *progBox = DrawPublish(DrawProgressBar(true, 0, "Initialise DVD .. (HOLD B if NO DVD Drive)")); dvd_reset(); // low-level, basic dvd_read_id(); if(!(PAD_ButtonsHeld(0) & PAD_BUTTON_B)) { dvd_set_streaming(*(char*)0x80000008); } drive_version(&driveVersion[0]); swissSettings.hasDVDDrive = *(u32*)&driveVersion[0] ? 2 : 0; if(!swissSettings.hasDVDDrive) { DrawDispose(progBox); progBox = DrawPublish(DrawMessageBox(D_INFO, "No DVD Drive Detected !!")); sleep(2); } DrawDispose(progBox); } }
int main(int argc, char **argv) { int i, j, k, treeNo, sumLength; char ch; TTree **treeSet; FILE *text_fv; clock_t totalStart; double totalSecs, scale, sum; char *ancestor; totalStart = clock(); ReadParams(argc, argv); if (rateHetero == CodonRates && invariableSites) { fprintf(stderr, "Invariable sites model cannot be used with codon rate heterogeneity.\n"); exit(4); } if (writeAncestors && fileFormat == NEXUSFormat) { fprintf(stderr, "Warning - When writing ancestral sequences, relaxed PHYLIP format is used.\n"); } if (writeAncestors && maxPartitions > 1) { fprintf(stderr, "Writing ancestral sequences can only be used for a single partition.\n"); exit(4); } if (!userSeed) randomSeed = CreateSeed(); SetSeed(randomSeed); if (!quiet) PrintTitle(); numTrees = OpenTreeFile(); /* if (!treeFile) { */ ReadFileParams(); /*} */ if ((ancestorSeq>0 && !hasAlignment) || ancestorSeq>numSequences) { fprintf(stderr, "Bad ancestral sequence number: %d (%d sequences loaded)\n", ancestorSeq, numSequences); exit(4); } if (textFile) { if ( (text_fv=fopen(textFileName, "rt"))==NULL ) { fprintf(stderr, "Error opening text file for insertion into output: '%s'\n", textFileName); exit(4); } } ancestor=NULL; if (hasAlignment) { AllocateMemory(); ReadFile(); if (numSites<0) numSites=numAlignmentSites; if (ancestorSeq>0) { if (numSites!=numAlignmentSites) { fprintf(stderr, "Ancestral sequence is of a different length to the simulated sequences (%d)\n", numAlignmentSites); exit(4); } ancestor=sequences[ancestorSeq-1]; } } else if (numSites<0) numSites=1000; SetModel(model); numTaxa=-1; scale=1.0; treeSet = (TTree **)malloc(sizeof(TTree **) * maxPartitions); if (treeSet==NULL) { fprintf(stderr, "Out of memory\n"); exit(5); } partitionLengths = (int *)malloc(sizeof(int) * maxPartitions); if (partitionLengths==NULL) { fprintf(stderr, "Out of memory\n"); exit(5); } partitionRates = (double *)malloc(sizeof(double) * maxPartitions); if (partitionRates==NULL) { fprintf(stderr, "Out of memory\n"); exit(5); } for (i = 0; i < maxPartitions; i++) { if ((treeSet[i]=NewTree())==NULL) { fprintf(stderr, "Out of memory\n"); exit(5); } } CreateRates(); treeNo=0; do { partitionLengths[0] = -1; ReadTree(tree_fv, treeSet[0], treeNo+1, 0, NULL, &partitionLengths[0], &partitionRates[0]); if (treeNo==0) { numTaxa=treeSet[0]->numTips; if (!quiet) fprintf(stderr, "Random number generator seed: %ld\n\n", randomSeed); if (fileFormat == NEXUSFormat) { fprintf(stdout, "#NEXUS\n"); fprintf(stdout, "[\nGenerated by %s %s\n\n", PROGRAM_NAME, VERSION_NUMBER); PrintVerbose(stdout); fprintf(stdout, "]\n\n"); } } else if (treeSet[0]->numTips != numTaxa) { fprintf(stderr, "All trees must have the same number of tips.\n"); exit(4); } if (maxPartitions == 1) { if (partitionLengths[0] != -1) { fprintf(stderr, "\nWARNING: The treefile contained partion lengths but only one partition\n"); fprintf(stderr, "was specified.\n"); } partitionLengths[0] = numSites; } sumLength = partitionLengths[0]; i = 1; while (sumLength < numSites && i <= maxPartitions) { if (!IsTreeAvail(tree_fv)) { fprintf(stderr, "\nA set of trees number %d had less partition length (%d) than\n", treeNo + 1, sumLength); fprintf(stderr, "was required to make a sequence of length %d.\n", numSites); exit(4); } ReadTree(tree_fv, treeSet[i], treeNo+1, treeSet[0]->numTips, treeSet[0]->names, &partitionLengths[i], &partitionRates[i]); if (treeSet[i]->numTips != numTaxa) { fprintf(stderr, "All trees must have the same number of tips.\n"); exit(4); } sumLength += partitionLengths[i]; i++; } if (i > maxPartitions) { fprintf(stderr, "\nA set of trees number %d had more partitions (%d) than\n", treeNo + 1, i); fprintf(stderr, "was specified in the user options (%d).\n", maxPartitions); } numPartitions = i; if (sumLength != numSites) { fprintf(stderr, "The sum of the partition lengths in the treefile does not equal\n"); fprintf(stderr, "the specified number of sites.\n"); exit(4); } for (i = 0; i < numPartitions; i++) CreateSequences(treeSet[i], partitionLengths[i]); if (numPartitions > 1) { sum = 0.0; for (i = 0; i < numPartitions; i++) sum += partitionRates[i] * partitionLengths[i]; for (i = 0; i < numPartitions; i++) partitionRates[i] *= numSites / sum; } if (treeNo==0 && verbose && !quiet) { PrintVerbose(stderr); InitProgressBar(numTrees*numDatasets); DrawProgressBar(); } for (i=0; i<numDatasets; i++) { SetCategories(); k = 0; for (j = 0; j < numPartitions; j++) { scale = partitionRates[j]; if (scaleTrees) { if (!treeSet[j]->rooted) { fprintf(stderr, "To scale tree length, they must be rooted and ultrametric.\n"); exit(4); } scale *= treeScale/treeSet[j]->totalLength; } else if (scaleBranches) scale *= branchScale; EvolveSequences(treeSet[j], k, partitionLengths[j], scale, ancestor); k += partitionLengths[j]; } if (writeAncestors) WriteAncestralSequences(stdout, treeSet[0]); else WriteSequences(stdout, (numTrees > 1 ? treeNo+1 : -1), (numDatasets > 1 ? i+1 : -1), treeSet, partitionLengths); if (writeRates) { WriteRates(stderr); } if (textFile) { while (!feof(text_fv)) { ch = fgetc(text_fv); if (!feof(text_fv)) fputc(ch, stdout); } fputc('\n', stdout); rewind(text_fv); } if (verbose && !quiet) ProgressBar(); } for (i = 0; i < numPartitions; i++) DisposeTree(treeSet[i]); treeNo++; } while (IsTreeAvail(tree_fv)); /* for (i = 0; i < maxPartitions; i++) FreeTree(treeSet[i]); */ if (treeFile) fclose(tree_fv); if (textFile) fclose(text_fv); totalSecs = (double)(clock() - totalStart) / CLOCKS_PER_SEC; if (!quiet) { fprintf(stderr, "Time taken: %G seconds\n", totalSecs); if (verboseMemory) fprintf(stderr, "Total memory used: %ld\n", totalMem); } return 0; }
void CStatusLineCtrl::OnPaint(wxPaintEvent& event) { wxPaintDC dc(this); wxRect rect = GetRect(); int refresh = 0; if (!m_data.IsOk() || rect.GetWidth() != m_data.GetWidth() || rect.GetHeight() != m_data.GetHeight()) { delete m_mdc; m_data = wxBitmap(rect.GetWidth(), rect.GetHeight()); m_mdc = new wxMemoryDC(m_data); refresh = 15; } int elapsed_seconds = 0; wxTimeSpan elapsed; int left = -1; wxFileOffset rate; wxString bytes_and_rate; int bar_split = -1; int permill = -1; if (!m_pStatus) { if (!m_pPreviousStatusText || *m_pPreviousStatusText != m_statusText) { // Clear background m_mdc->SetFont(GetFont()); m_mdc->SetPen(GetBackgroundColour()); m_mdc->SetBrush(GetBackgroundColour()); m_mdc->SetTextForeground(GetForegroundColour()); m_mdc->DrawRectangle(0, 0, rect.GetWidth(), rect.GetHeight()); wxCoord h = (rect.GetHeight() - m_textHeight) / 2; m_mdc->DrawText(m_statusText, 50, h); delete m_pPreviousStatusText; m_pPreviousStatusText = new wxString(m_statusText); refresh = 0; } } else { if (m_pPreviousStatusText) { delete m_pPreviousStatusText; m_pPreviousStatusText = 0; refresh = 15; } if (m_pStatus->started.IsValid()) { elapsed = wxDateTime::Now().Subtract(m_pStatus->started); elapsed_seconds = elapsed.GetSeconds().GetLo(); // Assume GetHi is always 0 } if (elapsed_seconds != m_last_elapsed_seconds) { refresh |= 1; m_last_elapsed_seconds = elapsed_seconds; } if (COptions::Get()->GetOptionVal(OPTION_SPEED_DISPLAY)) rate = GetCurrentSpeed(); else rate = GetSpeed(elapsed_seconds); if (elapsed_seconds && rate > -1) { left = ((m_pStatus->totalSize - m_pStatus->startOffset) / rate) - elapsed_seconds; if (left < 0) left = 0; } if (m_last_left != left) { refresh |= 2; m_last_left = left; } const wxString bytestr = CSizeFormat::Format(m_pStatus->currentOffset, true, CSizeFormat::bytes, COptions::Get()->GetOptionVal(OPTION_SIZE_USETHOUSANDSEP) != 0, 0); if (elapsed_seconds && rate > -1) { if (rate > (1000*1000)) bytes_and_rate.Printf(_("%s (%d.%d MB/s)"), bytestr.c_str(), (int)(rate / 1000 / 1000), (int)((rate / 1000 / 100) % 10)); else if (rate > 1000) bytes_and_rate.Printf(_("%s (%d.%d KB/s)"), bytestr.c_str(), (int)(rate / 1000), (int)((rate / 100) % 10)); else bytes_and_rate.Printf(_("%s (%d B/s)"), bytestr.c_str(), (int)rate); } else bytes_and_rate.Printf(_("%s (? B/s)"), bytestr.c_str()); if (m_last_bytes_and_rate != bytes_and_rate) { refresh |= 8; m_last_bytes_and_rate = bytes_and_rate; } if (m_pStatus->totalSize > 0) { bar_split = wxLongLong(m_pStatus->currentOffset * (PROGRESSBAR_WIDTH - 2) / m_pStatus->totalSize).GetLo(); if (bar_split > (PROGRESSBAR_WIDTH - 2)) bar_split = PROGRESSBAR_WIDTH - 2; if (m_pStatus->currentOffset > m_pStatus->totalSize) permill = 1001; else permill = wxLongLong(m_pStatus->currentOffset * 1000 / m_pStatus->totalSize).GetLo(); } if (m_last_bar_split != bar_split || m_last_permill != permill) { refresh |= 4; m_last_bar_split = bar_split; m_last_permill = permill; } } if (refresh) { m_mdc->SetFont(GetFont()); m_mdc->SetPen(GetBackgroundColour()); m_mdc->SetBrush(GetBackgroundColour()); m_mdc->SetTextForeground(GetForegroundColour()); // Get character height so that we can center the text vertically. wxCoord h = (rect.GetHeight() - m_textHeight) / 2; if (refresh & 1) { m_mdc->DrawRectangle(0, 0, m_fieldOffsets[0], rect.GetHeight()); DrawRightAlignedText(*m_mdc, elapsed.Format(_("%H:%M:%S elapsed")), m_fieldOffsets[0], h); } if (refresh & 2) { m_mdc->DrawRectangle(m_fieldOffsets[0], 0, m_fieldOffsets[1] - m_fieldOffsets[0], rect.GetHeight()); if (left != -1) { wxTimeSpan timeLeft(0, 0, left); DrawRightAlignedText(*m_mdc, timeLeft.Format(_("%H:%M:%S left")), m_fieldOffsets[1], h); } else DrawRightAlignedText(*m_mdc, _("--:--:-- left"), m_fieldOffsets[1], h); } if (refresh & 8) { m_mdc->DrawRectangle(m_fieldOffsets[3], 0, rect.GetWidth() - m_fieldOffsets[3], rect.GetHeight()); m_mdc->DrawText(bytes_and_rate, m_fieldOffsets[3], h); } if (refresh & 4) { if (bar_split != -1) DrawProgressBar(*m_mdc, m_fieldOffsets[2], 1, rect.GetHeight() - 2, bar_split, permill); else m_mdc->DrawRectangle(m_fieldOffsets[2], 0, m_fieldOffsets[3] - m_fieldOffsets[2], rect.GetHeight()); } } dc.Blit(0, 0, rect.GetWidth(), rect.GetHeight(), m_mdc, 0, 0); }
//-------------------------------------------------------------------------------------- // Name: NuiMenu::Render() // Desc: Renders the menu items and the cursor. //-------------------------------------------------------------------------------------- VOID NuiMenu::Render() const { assert( m_pd3dDevice != NULL ); // Nothing to render. if( m_pMenuItemList == NULL ) { return; } // Render each item in listed order for( DWORD dwItemIndex = 0; dwItemIndex < m_dwItemCount; ++ dwItemIndex ) { // Only render items that aren't hidden if( ! m_pMenuItemList[ dwItemIndex ].bHidden ) { switch( m_pMenuItemList[ dwItemIndex ].eItemType ) { // Render a button. Buttons are shown in different colors depending on whether they are disabled, // selectable or selected case NUI_MENU_ITEM_BUTTON: { D3DCOLOR color = m_settings.staticColor; if( m_pMenuItemList[ dwItemIndex ].dwItemID == m_dwHoveredItemID ) { color = m_settings.selectedColor; } else if( m_pMenuItemList[ dwItemIndex ].bEnabled && ! m_bIsDisabled ) { color = m_settings.selectableColor; } DrawButton( &m_pMenuItemList[ dwItemIndex ].Location, m_pMenuItemList[ dwItemIndex ].szText, color ); break; } // Render a check box. Check boxes are shown in different colors depending on whether they are disabled, // selectable or selected case NUI_MENU_ITEM_CHECK_BOX: { D3DCOLOR color = m_settings.staticColor; if( m_pMenuItemList[ dwItemIndex ].dwItemID == m_dwHoveredItemID ) { color = m_settings.selectedColor; } else if( m_pMenuItemList[ dwItemIndex ].bEnabled && ! m_bIsDisabled ) { color = m_settings.selectableColor; } DrawCheckBox( &m_pMenuItemList[ dwItemIndex ].Location, m_pMenuItemList[ dwItemIndex ].szText, color, m_pMenuItemList[ dwItemIndex ].fValue > 0.0f ); break; } case NUI_MENU_ITEM_FRAME: DrawFrame( &m_pMenuItemList[ dwItemIndex ].Location, m_settings.staticColor ); break; case NUI_MENU_ITEM_PANEL: DrawPanel( &m_pMenuItemList[ dwItemIndex ].Location, m_settings.panelColor ); break; case NUI_MENU_ITEM_PROGRESS_BAR: DrawProgressBar( &m_pMenuItemList[ dwItemIndex ].Location, m_pMenuItemList[ dwItemIndex ].fValue, m_settings.staticColor ); break; case NUI_MENU_ITEM_SPINNER: DrawSpinner( &m_pMenuItemList[ dwItemIndex ].Location, m_pMenuItemList[ dwItemIndex ].fValue, m_settings.staticColor ); break; case NUI_MENU_ITEM_TEXT: DrawText( &m_pMenuItemList[ dwItemIndex ].Location, m_pMenuItemList[ dwItemIndex ].szText, m_settings.staticColor, m_pMenuItemList[ dwItemIndex ].dwValue ); break; default: assert( false ); break; } } } // Add an alignment grid on top of the menu, if requested. if( m_settings.bDrawGuide ) { DrawAlignmentGrid(); } // Draw the cursor last, unless the whole menu is disabled if( ! m_bIsDisabled ) { DrawCursor(); } }