ShowImageWindow::ShowImageWindow(const entry_ref *ref, const BMessenger& trackerMessenger) : BWindow(BRect(5, 24, 250, 100), "", B_DOCUMENT_WINDOW, 0), fSavePanel(NULL), fBar(NULL), fOpenMenu(NULL), fBrowseMenu(NULL), fGoToPageMenu(NULL), fSlideShowDelay(NULL), fImageView(NULL), fStatusView(NULL), fModified(false), fFullScreen(false), fShowCaption(true), fPrintSettings(NULL), fResizerWindowMessenger(NULL), fResizeItem(NULL), fHeight(0), fWidth(0) { _LoadSettings(); // create menu bar fBar = new BMenuBar(BRect(0, 0, Bounds().right, 1), "menu_bar"); AddMenus(fBar); AddChild(fBar); BRect viewFrame = Bounds(); viewFrame.top = fBar->Bounds().Height() + 1; viewFrame.right -= B_V_SCROLL_BAR_WIDTH; viewFrame.bottom -= B_H_SCROLL_BAR_HEIGHT; // create the image view fImageView = new ShowImageView(viewFrame, "image_view", B_FOLLOW_ALL, B_WILL_DRAW | B_FRAME_EVENTS | B_FULL_UPDATE_ON_RESIZE | B_PULSE_NEEDED); // wrap a scroll view around the view BScrollView *scrollView = new BScrollView("image_scroller", fImageView, B_FOLLOW_ALL, 0, false, false, B_PLAIN_BORDER); AddChild(scrollView); const int32 kstatusWidth = 190; BRect rect; rect = Bounds(); rect.top = viewFrame.bottom + 1; rect.left = viewFrame.left + kstatusWidth; rect.right = viewFrame.right + 1; rect.bottom += 1; BScrollBar *horizontalScrollBar = new BScrollBar(rect, "hscroll", fImageView, 0, 150, B_HORIZONTAL); AddChild(horizontalScrollBar); rect.left = 0; rect.right = kstatusWidth - 1; rect.bottom -= 1; fStatusView = new ShowImageStatusView(rect, "status_view", B_FOLLOW_BOTTOM, B_WILL_DRAW); AddChild(fStatusView); rect = Bounds(); rect.top = viewFrame.top - 1; rect.left = viewFrame.right + 1; rect.bottom = viewFrame.bottom + 1; rect.right += 1; BScrollBar *verticalScrollBar = new BScrollBar(rect, "vscroll", fImageView, 0, 150, B_VERTICAL); AddChild(verticalScrollBar); SetSizeLimits(250, 100000, 100, 100000); // finish creating the window fImageView->SetImage(ref); fImageView->SetTrackerMessenger(trackerMessenger); if (InitCheck() != B_OK) { BAlert* alert; alert = new BAlert("ShowImage", "Could not load image! Either the file or an image translator for " "it does not exist.", "OK", NULL, NULL, B_WIDTH_AS_USUAL, B_INFO_ALERT); alert->Go(); // quit if file could not be opened Quit(); return; } // add View menu here so it can access ShowImageView methods BMenu* menu = new BMenu("View"); _BuildViewMenu(menu, false); fBar->AddItem(menu); _MarkMenuItem(fBar, MSG_DITHER_IMAGE, fImageView->GetDither()); UpdateTitle(); SetPulseRate(100000); // every 1/10 second; ShowImageView needs it for marching ants WindowRedimension(fImageView->GetBitmap()); fImageView->MakeFocus(true); // to receive KeyDown messages Show(); // Tell application object to query the clipboard // and tell this window if it contains interesting data or not be_app_messenger.SendMessage(B_CLIPBOARD_CHANGED); }
void DoMuscle(CompositeVect*CVLocation) { SetOutputFileName(g_pstrOutFileName); SetInputFileName(g_pstrInFileName); SetMaxIters(g_uMaxIters); SetSeqWeightMethod(g_SeqWeight1); TextFile fileIn(g_pstrInFileName); SeqVect v; v.FromFASTAFile(fileIn); const unsigned uSeqCount = v.Length(); if (0 == uSeqCount) Quit("No sequences in input file"); ALPHA Alpha = ALPHA_Undefined; switch (g_SeqType) { case SEQTYPE_Auto: Alpha = v.GuessAlpha(); break; case SEQTYPE_Protein: Alpha = ALPHA_Amino; break; case SEQTYPE_DNA: Alpha = ALPHA_DNA; break; case SEQTYPE_RNA: Alpha = ALPHA_RNA; break; default: Quit("Invalid seq type"); } SetAlpha(Alpha); v.FixAlpha(); PTR_SCOREMATRIX UserMatrix = 0; if (0 != g_pstrMatrixFileName) { const char *FileName = g_pstrMatrixFileName; const char *Path = getenv("MUSCLE_MXPATH"); if (Path != 0) { size_t n = strlen(Path) + 1 + strlen(FileName) + 1; char *NewFileName = new char[n]; sprintf(NewFileName, "%s/%s", Path, FileName); FileName = NewFileName; } TextFile File(FileName); UserMatrix = ReadMx(File); g_Alpha = ALPHA_Amino; g_PPScore = PPSCORE_SP; } SetPPScore(); if (0 != UserMatrix) g_ptrScoreMatrix = UserMatrix; unsigned uMaxL = 0; unsigned uTotL = 0; for (unsigned uSeqIndex = 0; uSeqIndex < uSeqCount; ++uSeqIndex) { unsigned L = v.GetSeq(uSeqIndex).Length(); uTotL += L; if (L > uMaxL) uMaxL = L; } SetIter(1); g_bDiags = g_bDiags1; SetSeqStats(uSeqCount, uMaxL, uTotL/uSeqCount); SetMuscleSeqVect(v); MSA::SetIdCount(uSeqCount); // Initialize sequence ids. // From this point on, ids must somehow propogate from here. for (unsigned uSeqIndex = 0; uSeqIndex < uSeqCount; ++uSeqIndex) v.SetSeqId(uSeqIndex, uSeqIndex); if (0 == uSeqCount) Quit("Input file '%s' has no sequences", g_pstrInFileName); if (1 == uSeqCount) { TextFile fileOut(g_pstrOutFileName, true); v.ToFile(fileOut); return; } if (uSeqCount > 1) MHackStart(v); // First iteration Tree GuideTree; if (0 != g_pstrUseTreeFileName) { // Discourage users... if (!g_bUseTreeNoWarn) fprintf(stderr, "%s", g_strUseTreeWarning); // Read tree from file TextFile TreeFile(g_pstrUseTreeFileName); GuideTree.FromFile(TreeFile); // Make sure tree is rooted if (!GuideTree.IsRooted()) Quit("User tree must be rooted"); if (GuideTree.GetLeafCount() != uSeqCount) Quit("User tree does not match input sequences"); const unsigned uNodeCount = GuideTree.GetNodeCount(); for (unsigned uNodeIndex = 0; uNodeIndex < uNodeCount; ++uNodeIndex) { if (!GuideTree.IsLeaf(uNodeIndex)) continue; const char *LeafName = GuideTree.GetLeafName(uNodeIndex); unsigned uSeqIndex; bool SeqFound = v.FindName(LeafName, &uSeqIndex); if (!SeqFound) Quit("Label %s in tree does not match sequences", LeafName); unsigned uId = v.GetSeqIdFromName(LeafName); GuideTree.SetLeafId(uNodeIndex, uId); } } else TreeFromSeqVect(v, GuideTree, g_Cluster1, g_Distance1, g_Root1, g_pstrDistMxFileName1); const char *Tree1 = ValueOpt("Tree1"); if (0 != Tree1) { TextFile f(Tree1, true); GuideTree.ToFile(f); if (g_bClusterOnly) return; } SetMuscleTree(GuideTree); ValidateMuscleIds(GuideTree); MSA msa; msa.SetCompositeVector(CVLocation); ProgNode *ProgNodes = 0; if (g_bLow) ProgNodes = ProgressiveAlignE(v, GuideTree, msa); else ProgressiveAlign(v, GuideTree, msa); SetCurrentAlignment(msa); if (0 != g_pstrComputeWeightsFileName) { extern void OutWeights(const char *FileName, const MSA &msa); SetMSAWeightsMuscle(msa); OutWeights(g_pstrComputeWeightsFileName, msa); return; } ValidateMuscleIds(msa); if (1 == g_uMaxIters || 2 == uSeqCount) { //TextFile fileOut(g_pstrOutFileName, true); //MHackEnd(msa); //msa.ToFile(fileOut); MuscleOutput(msa); return; } if (0 == g_pstrUseTreeFileName) { g_bDiags = g_bDiags2; SetIter(2); if (g_bLow) { if (0 != g_uMaxTreeRefineIters) RefineTreeE(msa, v, GuideTree, ProgNodes); } else RefineTree(msa, GuideTree); const char *Tree2 = ValueOpt("Tree2"); if (0 != Tree2) { TextFile f(Tree2, true); GuideTree.ToFile(f); } } SetSeqWeightMethod(g_SeqWeight2); SetMuscleTree(GuideTree); if (g_bAnchors) RefineVert(msa, GuideTree, g_uMaxIters - 2); else RefineHoriz(msa, GuideTree, g_uMaxIters - 2, false, false); #if 0 // Refining by subfamilies is disabled as it didn't give better // results. I tried doing this before and after RefineHoriz. // Should get back to this as it seems like this should work. RefineSubfams(msa, GuideTree, g_uMaxIters - 2); #endif ValidateMuscleIds(msa); ValidateMuscleIds(GuideTree); //TextFile fileOut(g_pstrOutFileName, true); //MHackEnd(msa); //msa.ToFile(fileOut); MuscleOutput(msa); }
void C4Application::GameTick() { // Exec depending on game state switch (AppState) { case C4AS_None: assert(AppState != C4AS_None); break; case C4AS_Quit: // Do nothing, the main loop will exit soon break; case C4AS_PreInit: if (!PreInit()) Quit(); break; case C4AS_Startup: SoundSystem.Execute(); MusicSystem.Execute(); // wait for the user to start a game break; case C4AS_StartGame: // immediate progress to next state; OpenGame will enter HandleMessage-loops in startup and lobby! C4Startup::CloseStartup(); AppState = C4AS_Game; // first-time game initialization if (!Game.Init()) { // set error flag (unless this was a lobby user abort) if (!C4GameLobby::UserAbort) Game.fQuitWithError = true; // no start: Regular QuitGame; this may reset the engine to startup mode if desired QuitGame(); break; } if(Config.Graphics.Windowed == 2 && FullScreenMode()) Application.SetVideoMode(GetConfigWidth(), GetConfigHeight(), Config.Graphics.BitDepth, Config.Graphics.RefreshRate, Config.Graphics.Monitor, true); break; case C4AS_AfterGame: // stop game Game.Clear(); if(Config.Graphics.Windowed == 2 && !NextMission && !isEditor) Application.SetVideoMode(GetConfigWidth(), GetConfigHeight(), Config.Graphics.BitDepth, Config.Graphics.RefreshRate, Config.Graphics.Monitor, false); AppState = C4AS_PreInit; // if a next mission is desired, set to start it if (NextMission) { Game.SetScenarioFilename(NextMission.getData()); Game.fLobby = Game.NetworkActive; Game.fObserve = false; NextMission.Clear(); } break; case C4AS_Game: // Game if (Game.IsRunning) Game.Execute(); // Sound SoundSystem.Execute(); MusicSystem.Execute(); // Gamepad if (pGamePadControl) pGamePadControl->Execute(); break; } }
int DebugKeys() { boolean esc; int level; if (IN_KeyDown(sc_C)) // C = count objects { CountObjects(); return 1; } if (IN_KeyDown(sc_E)) // E = quit level { playstate = ex_completed; // gamestate.mapon++; } if (IN_KeyDown(sc_F)) // F = facing spot { CenterWindow (14,4); US_Print ("X:"); US_PrintUnsigned (player->x); US_Print ("\nY:"); US_PrintUnsigned (player->y); US_Print ("\nA:"); US_PrintUnsigned (player->angle); VW_UpdateScreen(); IN_Ack(); return 1; } if (IN_KeyDown(sc_G)) // G = god mode { CenterWindow (12,2); if (godmode) US_PrintCentered ("God mode OFF"); else US_PrintCentered ("God mode ON"); VW_UpdateScreen(); IN_Ack(); godmode ^= 1; return 1; } if (IN_KeyDown(sc_H)) // H = hurt self { IN_ClearKeysDown (); TakeDamage (16,NULL); } else if (IN_KeyDown(sc_I)) // I = item cheat { CenterWindow (12,3); US_PrintCentered ("Free items!"); VW_UpdateScreen(); GivePoints(100000); HealSelf(99); if (gamestate.bestweapon<wp_chaingun) GiveWeapon (gamestate.bestweapon+1); gamestate.ammo += 50; if (gamestate.ammo > 99) gamestate.ammo = 99; DrawAmmo (); IN_Ack (); return 1; } else if (IN_KeyDown(sc_N)) // N = no clip { noclip^=1; CenterWindow (18,3); if (noclip) US_PrintCentered ("No clipping ON"); else US_PrintCentered ("No clipping OFF"); VW_UpdateScreen(); IN_Ack (); return 1; } else if (IN_KeyDown(sc_P)) // P = pause with no screen disruptioon { PicturePause (); return 1; } else if (IN_KeyDown(sc_Q)) // Q = fast quit Quit(NULL); else if (IN_KeyDown(sc_S)) // S = slow motion { singlestep^=1; CenterWindow (18,3); if (singlestep) US_PrintCentered ("Slow motion ON"); else US_PrintCentered ("Slow motion OFF"); VW_UpdateScreen(); IN_Ack (); return 1; } else if (IN_KeyDown(sc_T)) // T = shape test { ShapeTest(); return 1; } else if (IN_KeyDown(sc_W)) // W = warp to level { CenterWindow(26,3); PrintY+=6; #ifndef SPEAR US_Print(" Warp to which level(1-10):"); #elif defined(SPEARDEMO) US_Print(" Warp to which level(1-2):"); #else US_Print(" Warp to which level(1-21):"); #endif VW_UpdateScreen(); esc = !US_LineInput (px,py,str,NULL,true,2,0); if (!esc) { level = atoi (str); #ifndef SPEAR if (level>0 && level<11) #elif defined(SPEARDEMO) if (level>0 && level<2) #else if (level>0 && level<22) #endif { gamestate.mapon = level-1; playstate = ex_warped; } } return 1; } DrawPlayBorder(); return 0; }
void EventQueue::OnSignal(int signo) { Quit(); }
void QuitEmulator(void) { Quit(); }
void DeplanePic (int picnum) { byte far *plane0,far *plane1,far *plane2,far *plane3; byte by0,by1,by2,by3; unsigned x,y,b,color,shift,width,height; byte *dest; // // convert ega pixels to byte color values in a temp buffer // width = pictable[picnum-STARTPICS].width; height = pictable[picnum-STARTPICS].height; if (width>8 || height!=64) Quit ("DePlanePic: Bad size shape"); memset (spotvis,BACKGROUNDPIX,sizeof(spotvis)); plane0 = (byte _seg *)grsegs[picnum]; plane1 = plane0 + width*height; plane2 = plane1 + width*height; plane3 = plane2 + width*height; for (y=0;y<height;y++) { dest = &spotvis[y][0]; for (x=0;x<width;x++) { by0 = *plane0++; by1 = *plane1++; by2 = *plane2++; by3 = *plane3++; for (b=0;b<8;b++) { shift=8-b; color = 0; asm mov cl,[BYTE PTR shift] asm mov al,[BYTE PTR by3] asm rcr al,cl; asm rcl [BYTE PTR color],1; asm mov cl,[BYTE PTR shift] asm mov al,[BYTE PTR by2] asm rcr al,cl; asm rcl [BYTE PTR color],1; asm mov cl,[BYTE PTR shift] asm mov al,[BYTE PTR by1] asm rcr al,cl; asm rcl [BYTE PTR color],1; asm mov cl,[BYTE PTR shift] asm mov al,[BYTE PTR by0] asm rcr al,cl; asm rcl [BYTE PTR color],1; *dest++ = color; } // B } // X } // Y }
LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) { static UINT X = CLOCK_SIZE, Y = 2 * CLOCK_SIZE, unDir = 1; PAINTSTRUCT PtStr; HDC hDC; POINT stPos; static char lwP[20]; switch(message) { case WM_TIMER: CreateClockPic (); InvalidateRect (hwnd, 0, FALSE); //不要使用SendMessage (hwnd, WM_MOVE, 0, 20 * 1024 + 800); //使用如下代码 if (unDir) X += 5; else X-=5; if (X <= 0) unDir = 1; else if (X >= 1024-CLOCK_SIZE) unDir = 0; MoveWindow(hwnd, X, Y, CLOCK_SIZE, CLOCK_SIZE, TRUE); //UpdateWindow(hwnd); break; case WM_PAINT: hDC = BeginPaint (hwnd, &PtStr); BitBlt(hDC, PtStr.rcPaint.left, PtStr.rcPaint.top, PtStr.rcPaint.right - PtStr.rcPaint.left, PtStr.rcPaint.bottom - PtStr.rcPaint.top, ghDcClock, PtStr.rcPaint.left, PtStr.rcPaint.top, SRCCOPY); /*itoa(h2, lwP, 10); TextOut (hDC, 50, 20, lwP, strlen(lwP)); itoa(hwnd, lwP, 10); TextOut (hDC, 50, 40, lwP, strlen(lwP)); */EndPaint(hwnd, &PtStr); break; case WM_CREATE: //assert(hWinMain != hwnd); //printf("%d %d\n", hWinMain, hwnd); hWinMain = hwnd; Init(); break; case WM_COMMAND: switch(LOWORD(wParam)){ case IDM_BACK1: dwNowBack = IDB_BACK1; CheckMenuRadioItem (hMenu, IDM_BACK1, IDM_BACK2, IDM_BACK1, 0); break; case IDM_BACK2: dwNowBack = IDB_BACK2; CheckMenuRadioItem (hMenu, IDM_BACK1, IDM_BACK2, IDM_BACK2, 0); break; case IDM_CIRCLE1: dwNowCircle = IDB_CIRCLE1; CheckMenuRadioItem (hMenu, IDM_CIRCLE1, IDM_CIRCLE2, IDM_CIRCLE1, 0); break; case IDM_CIRCLE2: dwNowCircle = IDB_CIRCLE2; CheckMenuRadioItem (hMenu, IDM_CIRCLE1, IDM_CIRCLE2, IDM_CIRCLE2, 0); break; case IDM_EXIT: Quit(); return 0; default: break; } DeleteBackGround(); CreateBackGround(); CreateClockPic(); InvalidateRect (hwnd, NULL, FALSE); break; case WM_CLOSE: Quit(); break; case WM_RBUTTONDOWN: GetCursorPos (&stPos); TrackPopupMenu (hMenu, TPM_LEFTALIGN, stPos.x, stPos.y, 0, hwnd, 0); break; case WM_LBUTTONDOWN: SetCursor (hCursorMove); UpdateWindow(hwnd); ReleaseCapture(); SendMessage (hwnd, WM_NCLBUTTONDOWN, HTCAPTION, 0); SetCursor (hCursorMain); break; case WM_DESTROY: PostQuitMessage(0); break; default: return DefWindowProc(hwnd, message, wParam, lParam); } return 0; }
SCORE NWDASimple(const ProfPos *PA, unsigned uLengthA, const ProfPos *PB, unsigned uLengthB, PWPath &Path) { assert(uLengthB > 0 && uLengthA > 0); const unsigned uPrefixCountA = uLengthA + 1; const unsigned uPrefixCountB = uLengthB + 1; // Allocate DP matrices const size_t LM = uPrefixCountA*uPrefixCountB; SCORE *DPL_ = new SCORE[LM]; SCORE *DPM_ = new SCORE[LM]; SCORE *DPD_ = new SCORE[LM]; SCORE *DPE_ = new SCORE[LM]; SCORE *DPI_ = new SCORE[LM]; SCORE *DPJ_ = new SCORE[LM]; char *TBM_ = new char[LM]; char *TBD_ = new char[LM]; char *TBE_ = new char[LM]; char *TBI_ = new char[LM]; char *TBJ_ = new char[LM]; memset(TBM_, '?', LM); memset(TBD_, '?', LM); memset(TBE_, '?', LM); memset(TBI_, '?', LM); memset(TBJ_, '?', LM); DPM(0, 0) = 0; DPD(0, 0) = MINUS_INFINITY; DPE(0, 0) = MINUS_INFINITY; DPI(0, 0) = MINUS_INFINITY; DPJ(0, 0) = MINUS_INFINITY; DPM(1, 0) = MINUS_INFINITY; DPD(1, 0) = PA[0].m_scoreGapOpen; DPE(1, 0) = PA[0].m_scoreGapOpen2; TBD(1, 0) = 'D'; TBE(1, 0) = 'E'; DPI(1, 0) = MINUS_INFINITY; DPJ(1, 0) = MINUS_INFINITY; DPM(0, 1) = MINUS_INFINITY; DPD(0, 1) = MINUS_INFINITY; DPE(0, 1) = MINUS_INFINITY; DPI(0, 1) = PB[0].m_scoreGapOpen; DPJ(0, 1) = PB[0].m_scoreGapOpen2; TBI(0, 1) = 'I'; TBJ(0, 1) = 'J'; // Empty prefix of B is special case for (unsigned uPrefixLengthA = 2; uPrefixLengthA < uPrefixCountA; ++uPrefixLengthA) { DPM(uPrefixLengthA, 0) = MINUS_INFINITY; DPD(uPrefixLengthA, 0) = DPD(uPrefixLengthA - 1, 0) + g_scoreGapExtend.get(); DPE(uPrefixLengthA, 0) = DPE(uPrefixLengthA - 1, 0) + g_scoreGapExtend2.get(); TBD(uPrefixLengthA, 0) = 'D'; TBE(uPrefixLengthA, 0) = 'E'; DPI(uPrefixLengthA, 0) = MINUS_INFINITY; DPJ(uPrefixLengthA, 0) = MINUS_INFINITY; } // Empty prefix of A is special case for (unsigned uPrefixLengthB = 2; uPrefixLengthB < uPrefixCountB; ++uPrefixLengthB) { DPM(0, uPrefixLengthB) = MINUS_INFINITY; DPD(0, uPrefixLengthB) = MINUS_INFINITY; DPE(0, uPrefixLengthB) = MINUS_INFINITY; DPI(0, uPrefixLengthB) = DPI(0, uPrefixLengthB - 1) + g_scoreGapExtend.get(); DPJ(0, uPrefixLengthB) = DPJ(0, uPrefixLengthB - 1) + g_scoreGapExtend2.get(); TBI(0, uPrefixLengthB) = 'I'; TBJ(0, uPrefixLengthB) = 'J'; } // Special case to agree with NWFast, no D-I transitions so... DPD(uLengthA, 0) = MINUS_INFINITY; DPE(uLengthA, 0) = MINUS_INFINITY; // DPI(0, uLengthB) = MINUS_INFINITY; // DPJ(0, uLengthB) = MINUS_INFINITY; // ============ // Main DP loop // ============ SCORE scoreGapCloseB = MINUS_INFINITY; SCORE scoreGapClose2B = MINUS_INFINITY; for (unsigned uPrefixLengthB = 1; uPrefixLengthB < uPrefixCountB; ++uPrefixLengthB) { const ProfPos &PPB = PB[uPrefixLengthB - 1]; SCORE scoreGapCloseA = MINUS_INFINITY; SCORE scoreGapClose2A = MINUS_INFINITY; for (unsigned uPrefixLengthA = 1; uPrefixLengthA < uPrefixCountA; ++uPrefixLengthA) { const ProfPos &PPA = PA[uPrefixLengthA - 1]; { // Match M=LetterA+LetterB SCORE scoreLL = ScoreProfPos2(PPA, PPB); DPL(uPrefixLengthA, uPrefixLengthB) = scoreLL; SCORE scoreMM = DPM(uPrefixLengthA-1, uPrefixLengthB-1); SCORE scoreDM = DPD(uPrefixLengthA-1, uPrefixLengthB-1) + scoreGapCloseA; SCORE scoreEM = DPE(uPrefixLengthA-1, uPrefixLengthB-1) + scoreGapClose2A; SCORE scoreIM = DPI(uPrefixLengthA-1, uPrefixLengthB-1) + scoreGapCloseB; SCORE scoreJM = DPJ(uPrefixLengthA-1, uPrefixLengthB-1) + scoreGapClose2B; SCORE scoreBest; if (scoreMM >= scoreDM && scoreMM >= scoreEM && scoreMM >= scoreIM && scoreMM >= scoreJM) { scoreBest = scoreMM; TBM(uPrefixLengthA, uPrefixLengthB) = 'M'; } else if (scoreDM >= scoreMM && scoreDM >= scoreEM && scoreDM >= scoreIM && scoreDM >= scoreJM) { scoreBest = scoreDM; TBM(uPrefixLengthA, uPrefixLengthB) = 'D'; } else if (scoreEM >= scoreMM && scoreEM >= scoreDM && scoreEM >= scoreIM && scoreEM >= scoreJM) { scoreBest = scoreEM; TBM(uPrefixLengthA, uPrefixLengthB) = 'E'; } else if (scoreIM >= scoreMM && scoreIM >= scoreDM && scoreIM >= scoreEM && scoreIM >= scoreJM) { scoreBest = scoreIM; TBM(uPrefixLengthA, uPrefixLengthB) = 'I'; } else { assert(scoreJM >= scoreMM && scoreJM >= scoreDM && scoreJM >= scoreEM && scoreJM >= scoreIM); scoreBest = scoreJM; TBM(uPrefixLengthA, uPrefixLengthB) = 'J'; } DPM(uPrefixLengthA, uPrefixLengthB) = scoreBest + scoreLL; } { // Delete D=LetterA+GapB SCORE scoreMD = DPM(uPrefixLengthA-1, uPrefixLengthB) + PA[uPrefixLengthA-1].m_scoreGapOpen; SCORE scoreDD = DPD(uPrefixLengthA-1, uPrefixLengthB) + g_scoreGapExtend.get(); SCORE scoreBest; if (scoreMD >= scoreDD) { scoreBest = scoreMD; TBD(uPrefixLengthA, uPrefixLengthB) = 'M'; } else { assert(scoreDD >= scoreMD); scoreBest = scoreDD; TBD(uPrefixLengthA, uPrefixLengthB) = 'D'; } DPD(uPrefixLengthA, uPrefixLengthB) = scoreBest; } { // Delete E=LetterA+GapB SCORE scoreME = DPM(uPrefixLengthA-1, uPrefixLengthB) + PA[uPrefixLengthA-1].m_scoreGapOpen2; SCORE scoreEE = DPE(uPrefixLengthA-1, uPrefixLengthB) + g_scoreGapExtend2.get(); SCORE scoreBest; if (scoreME >= scoreEE) { scoreBest = scoreME; TBE(uPrefixLengthA, uPrefixLengthB) = 'M'; } else { assert(scoreEE >= scoreME); scoreBest = scoreEE; TBE(uPrefixLengthA, uPrefixLengthB) = 'E'; } DPE(uPrefixLengthA, uPrefixLengthB) = scoreBest; } // Insert I=GapA+LetterB { SCORE scoreMI = DPM(uPrefixLengthA, uPrefixLengthB-1) + PB[uPrefixLengthB - 1].m_scoreGapOpen; SCORE scoreII = DPI(uPrefixLengthA, uPrefixLengthB-1) + g_scoreGapExtend.get(); SCORE scoreBest; if (scoreMI >= scoreII) { scoreBest = scoreMI; TBI(uPrefixLengthA, uPrefixLengthB) = 'M'; } else { assert(scoreII > scoreMI); scoreBest = scoreII; TBI(uPrefixLengthA, uPrefixLengthB) = 'I'; } DPI(uPrefixLengthA, uPrefixLengthB) = scoreBest; } // Insert J=GapA+LetterB { SCORE scoreMJ = DPM(uPrefixLengthA, uPrefixLengthB-1) + PB[uPrefixLengthB - 1].m_scoreGapOpen2; SCORE scoreJJ = DPJ(uPrefixLengthA, uPrefixLengthB-1) + g_scoreGapExtend2.get(); SCORE scoreBest; if (scoreMJ >= scoreJJ) { scoreBest = scoreMJ; TBJ(uPrefixLengthA, uPrefixLengthB) = 'M'; } else { assert(scoreJJ > scoreMJ); scoreBest = scoreJJ; TBJ(uPrefixLengthA, uPrefixLengthB) = 'J'; } DPJ(uPrefixLengthA, uPrefixLengthB) = scoreBest; } scoreGapCloseA = PPA.m_scoreGapClose; scoreGapClose2A = PPA.m_scoreGapClose2; } scoreGapCloseB = PPB.m_scoreGapClose; scoreGapClose2B = PPB.m_scoreGapClose2; } #if TRACE Log("\n"); Log("DA Simple DPL:\n"); ListDP(DPL_, PA, PB, uPrefixCountA, uPrefixCountB); Log("\n"); Log("DA Simple DPM:\n"); ListDP(DPM_, PA, PB, uPrefixCountA, uPrefixCountB); Log("\n"); Log("DA Simple DPD:\n"); ListDP(DPD_, PA, PB, uPrefixCountA, uPrefixCountB); Log("\n"); Log("DA Simple DPE:\n"); ListDP(DPE_, PA, PB, uPrefixCountA, uPrefixCountB); Log("\n"); Log("DA Simple DPI:\n"); ListDP(DPI_, PA, PB, uPrefixCountA, uPrefixCountB); Log("\n"); Log("DA Simple DPJ:\n"); ListDP(DPJ_, PA, PB, uPrefixCountA, uPrefixCountB); Log("\n"); Log("DA Simple TBM:\n"); ListTB(TBM_, PA, PB, uPrefixCountA, uPrefixCountB); Log("\n"); Log("DA Simple TBD:\n"); ListTB(TBD_, PA, PB, uPrefixCountA, uPrefixCountB); Log("\n"); Log("DA Simple TBE:\n"); ListTB(TBE_, PA, PB, uPrefixCountA, uPrefixCountB); Log("\n"); Log("DA Simple TBI:\n"); ListTB(TBI_, PA, PB, uPrefixCountA, uPrefixCountB); Log("\n"); Log("DA Simple TBJ:\n"); ListTB(TBJ_, PA, PB, uPrefixCountA, uPrefixCountB); #endif // Trace-back // ========== Path.Clear(); // Find last edge SCORE M = DPM(uLengthA, uLengthB); SCORE D = DPD(uLengthA, uLengthB) + PA[uLengthA-1].m_scoreGapClose; SCORE E = DPE(uLengthA, uLengthB) + PA[uLengthA-1].m_scoreGapClose2; SCORE I = DPI(uLengthA, uLengthB) + PB[uLengthB-1].m_scoreGapClose; SCORE J = DPJ(uLengthA, uLengthB) + PB[uLengthB-1].m_scoreGapClose2; char cEdgeType = '?'; SCORE BestScore = M; cEdgeType = 'M'; if (D > BestScore) { cEdgeType = 'D'; BestScore = D; } if (E > BestScore) { cEdgeType = 'E'; BestScore = E; } if (I > BestScore) { cEdgeType = 'I'; BestScore = I; } if (J > BestScore) { cEdgeType = 'J'; BestScore = J; } #if TRACE Log("DA Simple: MAB=%.4g DAB=%.4g EAB=%.4g IAB=%.4g JAB=%.4g best=%c\n", M, D, E, I, J, cEdgeType); #endif unsigned PLA = uLengthA; unsigned PLB = uLengthB; for (;;) { PWEdge Edge; Edge.cType = XlatEdgeType(cEdgeType); Edge.uPrefixLengthA = PLA; Edge.uPrefixLengthB = PLB; #if TRACE Log("Prepend %c%d.%d\n", Edge.cType, PLA, PLB); #endif Path.PrependEdge(Edge); switch (cEdgeType) { case 'M': assert(PLA > 0); assert(PLB > 0); cEdgeType = TBM(PLA, PLB); --PLA; --PLB; break; case 'D': assert(PLA > 0); cEdgeType = TBD(PLA, PLB); --PLA; break; case 'E': assert(PLA > 0); cEdgeType = TBE(PLA, PLB); --PLA; break; case 'I': assert(PLB > 0); cEdgeType = TBI(PLA, PLB); --PLB; break; case 'J': assert(PLB > 0); cEdgeType = TBJ(PLA, PLB); --PLB; break; default: Quit("Invalid edge %c", cEdgeType); } if (0 == PLA && 0 == PLB) break; } Path.Validate(); // SCORE Score = TraceBack(PA, uLengthA, PB, uLengthB, DPM_, DPD_, DPI_, Path); #if TRACE SCORE scorePath = FastScorePath2(PA, uLengthA, PB, uLengthB, Path); Path.LogMe(); Log("Score = %s Path = %s\n", LocalScoreToStr(BestScore), LocalScoreToStr(scorePath)); #endif if (g_bKeepSimpleDP.get()) { g_DPM.get() = DPM_; g_DPD.get() = DPD_; g_DPE.get() = DPE_; g_DPI.get() = DPI_; g_DPJ.get() = DPJ_; g_TBM.get() = TBM_; g_TBD.get() = TBD_; g_TBE.get() = TBE_; g_TBI.get() = TBI_; g_TBJ.get() = TBJ_; } else { delete[] DPM_; delete[] DPD_; delete[] DPE_; delete[] DPI_; delete[] DPJ_; delete[] TBM_; delete[] TBD_; delete[] TBE_; delete[] TBI_; delete[] TBJ_; } return BestScore; }
void MM_GetPtr (memptr *baseptr,id0_unsigned_long_t size) { mmblocktype id0_far *scan,id0_far *lastscan,id0_far *endscan ,id0_far *purge,id0_far *next; id0_int_t search; id0_unsigned_t needed,startseg; needed = (size+15)/16; // convert size from bytes to paragraphs GETNEWBLOCK; // fill in start and next after a spot is found mmnew->length = needed; mmnew->useptr = baseptr; mmnew->attributes = BASEATTRIBUTES; for (search = 0; search<3; search++) { // // first search: try to allocate right after the rover, then on up // second search: search from the head pointer up to the rover // third search: compress memory, then scan from start if (search == 1 && mmrover == mmhead) search++; switch (search) { case 0: lastscan = mmrover; scan = mmrover->next; endscan = NULL; break; case 1: lastscan = mmhead; scan = mmhead->next; endscan = mmrover; break; case 2: MM_SortMem (); lastscan = mmhead; scan = mmhead->next; endscan = NULL; break; } startseg = lastscan->start + lastscan->length; while (scan != endscan) { if ((refkeen_current_gamever == BE_GAMEVER_KDREAMS2015) || (scan->start - startseg >= needed)) { // // got enough space between the end of lastscan and // the start of scan, so throw out anything in the middle // and allocate the new block // purge = lastscan->next; lastscan->next = mmnew; if (refkeen_current_gamever == BE_GAMEVER_KDREAMS2015) { // Add a few more bytes as a workaround for vanilla bugs // in places like CA_HuffExpand *baseptr = malloc(size+16); if (*baseptr == NULL) Quit ("Out of memory! Please make sure you have enough free memory."); } else { mmnew->start /*= *(id0_unsigned_t *)baseptr*/ = startseg; *baseptr = EMULATED_SEG_TO_PTR(startseg); } mmnew->next = scan; while ( purge != scan) { // free the purgable block next = purge->next; FREEBLOCK(purge); purge = next; // purge another if not at scan } mmrover = mmnew; return; // good allocation! } // // if this block is purge level zero or locked, skip past it // if ( (scan->attributes & LOCKBIT) || !(scan->attributes & PURGEBITS) ) { lastscan = scan; startseg = lastscan->start + lastscan->length; } scan=scan->next; // look at next line } } Quit ((current_gamever_int < 110) ? "MM_GetPtr: Out of memory!" : "Out of memory! Please make sure you have enough free memory."); }
void CIRCSock::ReadLine(const CString& sData) { CString sLine = sData; sLine.TrimRight("\n\r"); DEBUG("(" << m_pUser->GetUserName() << ") IRC -> ZNC [" << sLine << "]"); MODULECALL(OnRaw(sLine), m_pUser, NULL, return); if (sLine.Equals("PING ", false, 5)) { // Generate a reply and don't forward this to any user, // we don't want any PING forwarded PutIRC("PONG " + sLine.substr(5)); return; } else if (sLine.Token(1).Equals("PONG")) { // Block PONGs, we already responded to the pings return; } else if (sLine.Equals("ERROR ", false, 6)) { //ERROR :Closing Link: nick[24.24.24.24] (Excess Flood) CString sError(sLine.substr(6)); if (sError.Left(1) == ":") { sError.LeftChomp(); } m_pUser->PutStatus("Error from Server [" + sError + "]"); return; } CString sCmd = sLine.Token(1); if ((sCmd.length() == 3) && (isdigit(sCmd[0])) && (isdigit(sCmd[1])) && (isdigit(sCmd[2]))) { CString sServer = sLine.Token(0); sServer.LeftChomp(); unsigned int uRaw = sCmd.ToUInt(); CString sNick = sLine.Token(2); CString sRest = sLine.Token(3, true); switch (uRaw) { case 1: { // :irc.server.com 001 nick :Welcome to the Internet Relay Network nick if (m_bAuthed && sServer == "irc.znc.in") { // m_bAuthed == true => we already received another 001 => we might be in a traffic loop m_pUser->PutStatus("ZNC seems to be connected to itself, disconnecting..."); Quit(); return; } m_pUser->SetIRCServer(sServer); SetTimeout(240, TMO_READ); // Now that we are connected, let nature take its course PutIRC("WHO " + sNick); m_bAuthed = true; m_pUser->PutStatus("Connected!"); vector<CClient*>& vClients = m_pUser->GetClients(); for (unsigned int a = 0; a < vClients.size(); a++) { CClient* pClient = vClients[a]; CString sClientNick = pClient->GetNick(false); if (!sClientNick.Equals(sNick)) { // If they connected with a nick that doesn't match the one we got on irc, then we need to update them pClient->PutClient(":" + sClientNick + "!" + m_Nick.GetIdent() + "@" + m_Nick.GetHost() + " NICK :" + sNick); } } SetNick(sNick); MODULECALL(OnIRCConnected(), m_pUser, NULL, ); m_pUser->ClearRawBuffer(); m_pUser->AddRawBuffer(":" + sServer + " " + sCmd + " ", " " + sRest); CZNC::Get().ReleaseISpoof(); m_bISpoofReleased = true; break; } case 5: ParseISupport(sRest); m_pUser->UpdateExactRawBuffer(":" + sServer + " " + sCmd + " ", " " + sRest); break; case 2: case 3: case 4: case 250: // highest connection count case 251: // user count case 252: // oper count case 254: // channel count case 255: // client count case 265: // local users case 266: // global users m_pUser->UpdateRawBuffer(":" + sServer + " " + sCmd + " ", " " + sRest); break; case 305: m_pUser->SetIRCAway(false); break; case 306: m_pUser->SetIRCAway(true); break; case 324: { // MODE sRest.Trim(); CChan* pChan = m_pUser->FindChan(sRest.Token(0)); if (pChan) { pChan->SetModes(sRest.Token(1, true)); } } break; case 329: { sRest.Trim(); CChan* pChan = m_pUser->FindChan(sRest.Token(0)); if (pChan) { unsigned long ulDate = sLine.Token(4).ToULong(); pChan->SetCreationDate(ulDate); } } break; case 331: { // :irc.server.com 331 yournick #chan :No topic is set. CChan* pChan = m_pUser->FindChan(sLine.Token(3)); if (pChan) { pChan->SetTopic(""); } break; } case 332: { // :irc.server.com 332 yournick #chan :This is a topic CChan* pChan = m_pUser->FindChan(sLine.Token(3)); if (pChan) { CString sTopic = sLine.Token(4, true); sTopic.LeftChomp(); pChan->SetTopic(sTopic); } break; } case 333: { // :irc.server.com 333 yournick #chan setternick 1112320796 CChan* pChan = m_pUser->FindChan(sLine.Token(3)); if (pChan) { sNick = sLine.Token(4); unsigned long ulDate = sLine.Token(5).ToULong(); pChan->SetTopicOwner(sNick); pChan->SetTopicDate(ulDate); } break; } case 352: { // :irc.yourserver.com 352 yournick #chan ident theirhost.com irc.theirserver.com theirnick H :0 Real Name sServer = sLine.Token(0); sNick = sLine.Token(7); CString sIdent = sLine.Token(4); CString sHost = sLine.Token(5); sServer.LeftChomp(); if (sNick.Equals(GetNick())) { m_Nick.SetIdent(sIdent); m_Nick.SetHost(sHost); } m_pUser->SetIRCNick(m_Nick); m_pUser->SetIRCServer(sServer); const vector<CChan*>& vChans = m_pUser->GetChans(); for (unsigned int a = 0; a < vChans.size(); a++) { vChans[a]->OnWho(sNick, sIdent, sHost); } break; } case 353: { // NAMES sRest.Trim(); // Todo: allow for non @+= server msgs CChan* pChan = m_pUser->FindChan(sRest.Token(1)); // If we don't know that channel, some client might have // requested a /names for it and we really should forward this. if (pChan) { CString sNicks = sRest.Token(2, true); if (sNicks.Left(1) == ":") { sNicks.LeftChomp(); } pChan->AddNicks(sNicks); } ForwardRaw353(sLine); // We forwarded it already, so return return; } case 366: { // end of names list m_pUser->PutUser(sLine); // First send them the raw // :irc.server.com 366 nick #chan :End of /NAMES list. CChan* pChan = m_pUser->FindChan(sRest.Token(0)); if (pChan) { if (pChan->IsOn()) { // If we are the only one in the chan, set our default modes if (pChan->GetNickCount() == 1) { CString sModes = pChan->GetDefaultModes(); if (sModes.empty()) { sModes = m_pUser->GetDefaultChanModes(); } if (!sModes.empty()) { PutIRC("MODE " + pChan->GetName() + " " + sModes); } } } } return; // return so we don't send them the raw twice } case 375: // begin motd case 422: // MOTD File is missing m_pUser->ClearMotdBuffer(); case 372: // motd case 376: // end motd m_pUser->AddMotdBuffer(":" + sServer + " " + sCmd + " ", " " + sRest); break; case 437: // :irc.server.net 437 * badnick :Nick/channel is temporarily unavailable // :irc.server.net 437 mynick badnick :Nick/channel is temporarily unavailable // :irc.server.net 437 mynick badnick :Cannot change nickname while banned on channel if (m_pUser->IsChan(sRest.Token(0)) || sNick != "*") break; case 432: // :irc.server.com 432 * nick :Erroneous Nickname: Illegal characters case 433: { CString sBadNick = sRest.Token(0); if (!m_bAuthed) { SendAltNick(sBadNick); return; } break; } case 451: // :irc.server.com 451 CAP :You have not registered // Servers that dont support CAP will give us this error, dont send it to the client if (sNick.Equals("CAP")) return; case 470: { // :irc.unreal.net 470 mynick [Link] #chan1 has become full, so you are automatically being transferred to the linked channel #chan2 // :mccaffrey.freenode.net 470 mynick #electronics ##electronics :Forwarding to another channel // freenode style numeric CChan* pChan = m_pUser->FindChan(sRest.Token(0)); if (!pChan) { // unreal style numeric pChan = m_pUser->FindChan(sRest.Token(1)); } if (pChan) { pChan->Disable(); m_pUser->PutStatus("Channel [" + pChan->GetName() + "] is linked to " "another channel and was thus disabled."); } break; } } } else {
void MakeRootMSA(const SeqVect &v, const Tree &GuideTree, ProgNode Nodes[], MSA &a) { #if TRACE Log("MakeRootMSA Tree="); GuideTree.LogMe(); #endif const unsigned uSeqCount = v.GetSeqCount(); unsigned uColCount = uInsane; unsigned uSeqIndex = 0; const unsigned uTreeNodeCount = GuideTree.GetNodeCount(); const unsigned uRootNodeIndex = GuideTree.GetRootNodeIndex(); const PWPath &RootPath = Nodes[uRootNodeIndex].m_Path; const unsigned uRootColCount = RootPath.GetEdgeCount(); const unsigned uEstringSize = uRootColCount + 1; short *Estring1 = new short[uEstringSize]; short *Estring2 = new short[uEstringSize]; SetProgressDesc("Root alignment"); unsigned uTreeNodeIndex = GetFirstNodeIndex(GuideTree); do { Progress(uSeqIndex, uSeqCount); unsigned uId = GuideTree.GetLeafId(uTreeNodeIndex); const Seq &s = *(v[uId]); Seq sRootE; short *es = MakeRootSeqE(s, GuideTree, uTreeNodeIndex, Nodes, sRootE, Estring1, Estring2); Nodes[uTreeNodeIndex].m_EstringL = EstringNewCopy(es); #if VALIDATE Seq sRoot; MakeRootSeq(s, GuideTree, uTreeNodeIndex, Nodes, sRoot); if (!sRoot.Eq(sRootE)) { Log("sRoot="); sRoot.LogMe(); Log("sRootE="); sRootE.LogMe(); Quit("Root seqs differ"); } #if TRACE Log("MakeRootSeq=\n"); sRoot.LogMe(); #endif #endif if (uInsane == uColCount) { uColCount = sRootE.Length(); a.SetSize(uSeqCount, uColCount); } else { assert(uColCount == sRootE.Length()); } a.SetSeqName(uSeqIndex, s.GetName()); a.SetSeqId(uSeqIndex, uId); for (unsigned uColIndex = 0; uColIndex < uColCount; ++uColIndex) a.SetChar(uSeqIndex, uColIndex, sRootE[uColIndex]); ++uSeqIndex; uTreeNodeIndex = GetNextNodeIndex(GuideTree, uTreeNodeIndex); } while (NULL_NEIGHBOR != uTreeNodeIndex); delete[] Estring1; delete[] Estring2; ProgressStepsDone(); assert(uSeqIndex == uSeqCount); }
void CFtpDialog::MessageReceived(BMessage *msg) { switch (msg->what) { case 'cnct': Connect(); break; case msg_ServerNameChanged: fServerName->MarkAsInvalid(false); break; case msg_SelectedDirectory: { BMenuItem *src; FailOSErr(msg->FindPointer("source", (void**)&src)); strcpy(fPath, "/"); if (src != fDirectoryField->Menu()->ItemAt(0)) { int i = 1; while (true) { if (i >= fDirectoryField->Menu()->CountItems()) break; BMenuItem *I = fDirectoryField->Menu()->ItemAt(i); strcat(fPath, I->Label()); strcat(fPath, "/"); if (src == I) break; ++i; } } ChangeDirectory(); break; } case msg_SelectedListItem: { CFtpListItem *i = dynamic_cast<CFtpListItem*>( fListView->ItemAt(fListView->CurrentSelection())); if (i == reinterpret_cast<CFtpListItem*>(NULL)) { beep(); return; } if (i->IsDirectory()) { strcat(fPath, *i); strcat(fPath, "/"); ChangeDirectory(); } else if (OkClicked()) Quit(); break; } case msg_ToggleDot: ListDirectory(); break; default: HDialog::MessageReceived(msg); break; } } // CFtpDialog::MessageReceived
// // Recycle // // Check timer and refund resources once recycled // void UnitRecycle::StateRecycle() { // Apply progress progressTotal -= progressMax; // Has recycling finished if (progressTotal <= 0.0F) { // Refund the resources if (subject->GetTeam() && refund > 0) { // Calculate the total refund U32 totalRefund = U32(subject->UnitType()->GetRecyclePercentage() * refund); // Add to the team subject->GetTeam()->AddResourceStore(totalRefund); // Report the resource type subject->GetTeam()->ReportResource(totalRefund, "resource.recycled"); // Generate a message if (Team::GetDisplayTeam() == subject->GetTeam()) { CON_MSG((TRANSLATE(("#game.messages.recyclerefund", 2, subject->GetUpgradedUnit().GetDesc(), totalRefund)))); } } // Trigger finish FX subject->StartGenericFX(0x2062BAAD, NULL, TRUE); // "Recycle::Finish" // Did this building consume its constructor if ( subject->UnitType()->GetConstructorType() && !subject->UnitType()->GetConstructorType()->GetIsFacility() && subject->UnitType()->GetConstructorConsume() ) { // Ensure the constructors resources are initialized subject->UnitType()->GetConstructorType()->InitializeResources(); // Create a fresh new constructor UnitObj *unit = subject->UnitType()->GetConstructorType()->SpawnClosest ( subject->Position(), subject->GetTeam() ); // If this team is controlled by AI then assign the // constructor to the primary base (if there is one) if (unit && unit->GetTeam() && unit->GetTeam()->IsAI()) { Strategic::Object *object = unit->GetTeam()->GetStrategicObject(); if (object) { Strategic::Base *base = object->GetBaseManager().GetPrimaryBase(); if (base) { base->AddUnit(unit); base->AddConstructor(unit); } } } } // Remove the object subject->MarkForDeletion(); // Remove boarded object if (subject->UnitType()->CanBoard() && subject->GetBoardManager()->InUse()) { subject->GetBoardManager()->GetUnitObj()->SelfDestruct(); } // Recycle completed Quit(); } }
void MSA::GetFractionalWeightedCounts(unsigned uColIndex, bool bNormalize, FCOUNT fcCounts[], FCOUNT *ptrfcGapStart, FCOUNT *ptrfcGapEnd, FCOUNT *ptrfcGapExtend, FCOUNT *ptrfOcc, FCOUNT *ptrfcLL, FCOUNT *ptrfcLG, FCOUNT *ptrfcGL, FCOUNT *ptrfcGG) const { const unsigned uSeqCount = GetSeqCount(); const unsigned uColCount = GetColCount(); const char* seqName; memset(fcCounts, 0, g_AlphaSize*sizeof(FCOUNT)); WEIGHT wTotal = 0; FCOUNT fGap = 0; for (unsigned uSeqIndex = 0; uSeqIndex < uSeqCount; ++uSeqIndex) { const WEIGHT w = GetSeqWeight(uSeqIndex); if (IsGap(uSeqIndex, uColIndex)) { fGap += w; continue; } else if (IsWildcard(uSeqIndex, uColIndex)) { const unsigned uLetter = GetLetterEx(uSeqIndex, uColIndex); switch (g_Alpha) { case ALPHA_Amino: switch (uLetter) { case AX_B: // D or N fcCounts[AX_D] += w/2; fcCounts[AX_N] += w/2; break; case AX_Z: // E or Q fcCounts[AX_E] += w/2; fcCounts[AX_Q] += w/2; break; default: // any { const FCOUNT f = w/20; for (unsigned uLetter = 0; uLetter < 20; ++uLetter) fcCounts[uLetter] += f; break; } } break; case ALPHA_DNA: case ALPHA_RNA: switch (uLetter) { case AX_R: // G or A fcCounts[NX_G] += w/2; fcCounts[NX_A] += w/2; break; case AX_Y: // C or T/U fcCounts[NX_C] += w/2; fcCounts[NX_T] += w/2; break; default: // any const FCOUNT f = w/20; for (unsigned uLetter = 0; uLetter < 4; ++uLetter) fcCounts[uLetter] += f; break; } break; default: Quit("Alphabet %d not supported", g_Alpha); } continue; } unsigned uLetter = GetLetter(uSeqIndex, uColIndex); //BEGIN MODIFICATIONS TO MUSCLE int original=0; for(unsigned i=0; i<uColIndex; i++){ if (i >= this->GetColCount()){break;} ++original; char c = GetChar(uSeqIndex, i); if(c== '-'){ original--; } } seqName = this->GetSeqName(uSeqIndex); int compositeVectPosition; compositeVectPosition = atoi(seqName); CompositeVect CV = *CVLocation; Composite* CVL = CV[compositeVectPosition]; Composite C = *CVL; for(int j=0; j<21; j++){ fcCounts[j] = w*C[original][j]; wTotal = w*C[original][j]; } //ORIGINAL MUSLCE LINE WAS: //fcCounts[uLetter] += w; //wTotal += w; //END MODIFICATIONS TO MUSCLE } *ptrfOcc = (float) (1.0 - fGap); if (bNormalize && wTotal > 0) { if (wTotal > 1.001) Quit("wTotal=%g\n", wTotal); for (unsigned uLetter = 0; uLetter < g_AlphaSize; ++uLetter) fcCounts[uLetter] /= wTotal; // AssertNormalized(fcCounts); } FCOUNT fcStartCount = 0; if (uColIndex == 0) { for (unsigned uSeqIndex = 0; uSeqIndex < uSeqCount; ++uSeqIndex) if (IsGap(uSeqIndex, uColIndex)) fcStartCount += GetSeqWeight(uSeqIndex); } else { for (unsigned uSeqIndex = 0; uSeqIndex < uSeqCount; ++uSeqIndex) if (IsGap(uSeqIndex, uColIndex) && !IsGap(uSeqIndex, uColIndex - 1)) fcStartCount += GetSeqWeight(uSeqIndex); } FCOUNT fcEndCount = 0; if (uColCount - 1 == uColIndex) { for (unsigned uSeqIndex = 0; uSeqIndex < uSeqCount; ++uSeqIndex) if (IsGap(uSeqIndex, uColIndex)) fcEndCount += GetSeqWeight(uSeqIndex); } else { for (unsigned uSeqIndex = 0; uSeqIndex < uSeqCount; ++uSeqIndex) if (IsGap(uSeqIndex, uColIndex) && !IsGap(uSeqIndex, uColIndex + 1)) fcEndCount += GetSeqWeight(uSeqIndex); } FCOUNT LL = 0; FCOUNT LG = 0; FCOUNT GL = 0; FCOUNT GG = 0; for (unsigned uSeqIndex = 0; uSeqIndex < uSeqCount; ++uSeqIndex) { WEIGHT w = GetSeqWeight(uSeqIndex); bool bLetterHere = !IsGap(uSeqIndex, uColIndex); bool bLetterPrev = (uColIndex == 0 || !IsGap(uSeqIndex, uColIndex - 1)); if (bLetterHere) { if (bLetterPrev) LL += w; else GL += w; } else { if (bLetterPrev) LG += w; else GG += w; } } FCOUNT fcExtendCount = 0; if (uColIndex > 0 && uColIndex < GetColCount() - 1) for (unsigned uSeqIndex = 0; uSeqIndex < uSeqCount; ++uSeqIndex) if (IsGap(uSeqIndex, uColIndex) && IsGap(uSeqIndex, uColIndex - 1) && IsGap(uSeqIndex, uColIndex + 1)) fcExtendCount += GetSeqWeight(uSeqIndex); *ptrfcLL = LL; *ptrfcLG = LG; *ptrfcGL = GL; *ptrfcGG = GG; *ptrfcGapStart = fcStartCount; *ptrfcGapEnd = fcEndCount; *ptrfcGapExtend = fcExtendCount; }
void UrlWrapper::ReadyToRun(void) { Quit(); }
int main(int argc, char **argv) { char str[256]; int16 i16; HANDLE rom_fh; const char *rom_path; uint32 rom_size; DWORD actual; uint8 *rom_tmp; // Initialize variables RAMBase = 0; // Print some info printf(GetString(STR_ABOUT_TEXT1), VERSION_MAJOR, VERSION_MINOR); printf(" %s\n", GetString(STR_ABOUT_TEXT2)); // Read preferences PrefsInit(NULL, argc, argv); // Parse command line arguments for (int i=1; i<argc; i++) { if (strcmp(argv[i], "--help") == 0) { usage(argv[0]); } else if (argv[i][0] == '-') { fprintf(stderr, "Unrecognized option '%s'\n", argv[i]); usage(argv[0]); } } // Check we are using a Windows NT kernel >= 4.0 OSVERSIONINFO osvi; ZeroMemory(&osvi, sizeof(OSVERSIONINFO)); osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); if (!GetVersionEx(&osvi)) { ErrorAlert("Could not determine OS type"); QuitEmulator(); } win_os = osvi.dwPlatformId; win_os_major = osvi.dwMajorVersion; if (win_os != VER_PLATFORM_WIN32_NT || win_os_major < 4) { ErrorAlert(GetString(STR_NO_WIN32_NT_4)); QuitEmulator(); } // Check that drivers are installed if (!check_drivers()) QuitEmulator(); // Load win32 libraries KernelInit(); // FIXME: default to DIB driver if (getenv("SDL_VIDEODRIVER") == NULL) putenv("SDL_VIDEODRIVER=windib"); // Initialize SDL system int sdl_flags = 0; #ifdef USE_SDL_VIDEO sdl_flags |= SDL_INIT_VIDEO; #endif #ifdef USE_SDL_AUDIO sdl_flags |= SDL_INIT_AUDIO; #endif assert(sdl_flags != 0); if (SDL_Init(sdl_flags) == -1) { char str[256]; sprintf(str, "Could not initialize SDL: %s.\n", SDL_GetError()); ErrorAlert(str); goto quit; } atexit(SDL_Quit); #ifdef ENABLE_MON // Initialize mon mon_init(); #endif // Install SIGSEGV handler for CPU emulator if (!sigsegv_install_handler(sigsegv_handler)) { sprintf(str, GetString(STR_SIGSEGV_INSTALL_ERR), strerror(errno)); ErrorAlert(str); goto quit; } // Initialize VM system vm_init(); // Get system info PVR = 0x00040000; // Default: 604 CPUClockSpeed = 100000000; // Default: 100MHz BusClockSpeed = 100000000; // Default: 100MHz TimebaseSpeed = 25000000; // Default: 25MHz PVR = 0x000c0000; // Default: 7400 (with AltiVec) D(bug("PVR: %08x (assumed)\n", PVR)); // Init system routines SysInit(); // Show preferences editor if (!PrefsFindBool("nogui")) if (!PrefsEditor()) goto quit; // Create areas for Kernel Data if (!kernel_data_init()) goto quit; kernel_data = (KernelData *)Mac2HostAddr(KERNEL_DATA_BASE); emulator_data = &kernel_data->ed; KernelDataAddr = KERNEL_DATA_BASE; D(bug("Kernel Data at %p (%08x)\n", kernel_data, KERNEL_DATA_BASE)); D(bug("Emulator Data at %p (%08x)\n", emulator_data, KERNEL_DATA_BASE + offsetof(KernelData, ed))); // Create area for DR Cache if (vm_mac_acquire(DR_EMULATOR_BASE, DR_EMULATOR_SIZE) < 0) { sprintf(str, GetString(STR_DR_EMULATOR_MMAP_ERR), strerror(errno)); ErrorAlert(str); goto quit; } dr_emulator_area_mapped = true; if (vm_mac_acquire(DR_CACHE_BASE, DR_CACHE_SIZE) < 0) { sprintf(str, GetString(STR_DR_CACHE_MMAP_ERR), strerror(errno)); ErrorAlert(str); goto quit; } dr_cache_area_mapped = true; DRCacheAddr = (uint32)Mac2HostAddr(DR_CACHE_BASE); D(bug("DR Cache at %p (%08x)\n", DRCacheAddr, DR_CACHE_BASE)); // Create area for SheepShaver data if (!SheepMem::Init()) { sprintf(str, GetString(STR_SHEEP_MEM_MMAP_ERR), strerror(errno)); ErrorAlert(str); goto quit; } // Create area for Mac ROM if (vm_mac_acquire(ROM_BASE, ROM_AREA_SIZE) < 0) { sprintf(str, GetString(STR_ROM_MMAP_ERR), strerror(errno)); ErrorAlert(str); goto quit; } ROMBase = ROM_BASE; ROMBaseHost = Mac2HostAddr(ROMBase); rom_area_mapped = true; D(bug("ROM area at %p (%08x)\n", ROMBaseHost, ROMBase)); // Create area for Mac RAM RAMSize = PrefsFindInt32("ramsize"); if (RAMSize < 8*1024*1024) { WarningAlert(GetString(STR_SMALL_RAM_WARN)); RAMSize = 8*1024*1024; } RAMBase = 0; if (vm_mac_acquire(RAMBase, RAMSize) < 0) { sprintf(str, GetString(STR_RAM_MMAP_ERR), strerror(errno)); ErrorAlert(str); goto quit; } RAMBaseHost = Mac2HostAddr(RAMBase); ram_area_mapped = true; D(bug("RAM area at %p (%08x)\n", RAMBaseHost, RAMBase)); if (RAMBase > ROMBase) { ErrorAlert(GetString(STR_RAM_HIGHER_THAN_ROM_ERR)); goto quit; } // Load Mac ROM rom_path = PrefsFindString("rom"); rom_fh = CreateFile(rom_path && *rom_path ? rom_path : ROM_FILE_NAME, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if (rom_fh == INVALID_HANDLE_VALUE) { rom_fh = CreateFile(ROM_FILE_NAME2, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if (rom_fh == INVALID_HANDLE_VALUE) { ErrorAlert(GetString(STR_NO_ROM_FILE_ERR)); goto quit; } } printf(GetString(STR_READING_ROM_FILE)); rom_size = GetFileSize(rom_fh, NULL); rom_tmp = new uint8[ROM_SIZE]; ReadFile(rom_fh, (void *)rom_tmp, ROM_SIZE, &actual, NULL); CloseHandle(rom_fh); // Decode Mac ROM if (!DecodeROM(rom_tmp, actual)) { if (rom_size != 4*1024*1024) { ErrorAlert(GetString(STR_ROM_SIZE_ERR)); goto quit; } else { ErrorAlert(GetString(STR_ROM_FILE_READ_ERR)); goto quit; } } delete[] rom_tmp; // Initialize native timers timer_init(); // Initialize everything if (!InitAll(NULL)) goto quit; D(bug("Initialization complete\n")); // Write protect ROM vm_protect(ROMBaseHost, ROM_AREA_SIZE, VM_PAGE_READ); // Start 60Hz thread tick_thread_cancel = false; tick_thread_active = ((tick_thread = create_thread(tick_func)) != NULL); SetThreadPriority(tick_thread, THREAD_PRIORITY_ABOVE_NORMAL); D(bug("Tick thread installed (%ld)\n", tick_thread)); // Start NVRAM watchdog thread memcpy(last_xpram, XPRAM, XPRAM_SIZE); nvram_thread_cancel = false; nvram_thread_active = ((nvram_thread = create_thread(nvram_func, NULL)) != NULL); SetThreadPriority(nvram_thread, THREAD_PRIORITY_BELOW_NORMAL); D(bug("NVRAM thread installed (%ld)\n", nvram_thread)); // Get my thread ID and jump to ROM boot routine emul_thread = GetCurrentThread(); D(bug("Jumping to ROM\n")); #ifdef _MSC_VER __try { #endif jump_to_rom(ROMBase + 0x310000); #ifdef _MSC_VER } __except (main_exception_filter(GetExceptionInformation())) {} #endif D(bug("Returned from ROM\n")); quit: Quit(); return 0; }
void PM_Startup() { char fname[13] = "vswap."; strcat(fname,extension); FILE *file = fopen(fname,"rb"); if(!file) CA_CannotOpen(fname); ChunksInFile = 0; fread(&ChunksInFile, sizeof(word), 1, file); PMSpriteStart = 0; fread(&PMSpriteStart, sizeof(word), 1, file); PMSoundStart = 0; fread(&PMSoundStart, sizeof(word), 1, file); uint32_t* pageOffsets = (uint32_t *) malloc((ChunksInFile + 1) * sizeof(int32_t)); CHECKMALLOCRESULT(pageOffsets); fread(pageOffsets, sizeof(uint32_t), ChunksInFile, file); word *pageLengths = (word *) malloc(ChunksInFile * sizeof(word)); CHECKMALLOCRESULT(pageLengths); fread(pageLengths, sizeof(word), ChunksInFile, file); fseek(file, 0, SEEK_END); long fileSize = ftell(file); long pageDataSize = fileSize - pageOffsets[0]; if(pageDataSize > (size_t) -1) Quit("The page file \"%s\" is too large!", fname); pageOffsets[ChunksInFile] = fileSize; uint32_t dataStart = pageOffsets[0]; int i; // Check that all pageOffsets are valid for(i = 0; i < ChunksInFile; i++) { if(!pageOffsets[i]) continue; // sparse page if(pageOffsets[i] < dataStart || pageOffsets[i] >= (size_t) fileSize) Quit("Illegal page offset for page %i: %u (filesize: %u)", i, pageOffsets[i], fileSize); } // Calculate total amount of padding needed for sprites and sound info page int alignPadding = 0; for(i = PMSpriteStart; i < PMSoundStart; i++) { if(!pageOffsets[i]) continue; // sparse page uint32_t offs = pageOffsets[i] - dataStart + alignPadding; if(offs & 1) alignPadding++; } if((pageOffsets[ChunksInFile - 1] - dataStart + alignPadding) & 1) alignPadding++; PMPageDataSize = (size_t) pageDataSize + alignPadding; PMPageData = (uint32_t *) malloc(PMPageDataSize); CHECKMALLOCRESULT(PMPageData); PMPages = (uint8_t **) malloc((ChunksInFile + 1) * sizeof(uint8_t *)); CHECKMALLOCRESULT(PMPages); // Load pages and initialize PMPages pointers uint8_t *ptr = (uint8_t *) PMPageData; for(i = 0; i < ChunksInFile; i++) { if(i >= PMSpriteStart && i < PMSoundStart || i == ChunksInFile - 1) { size_t offs = ptr - (uint8_t *) PMPageData; // pad with zeros to make it 2-byte aligned if(offs & 1) { *ptr++ = 0; if(i == ChunksInFile - 1) PMSoundInfoPagePadded = true; } } PMPages[i] = ptr; if(!pageOffsets[i]) continue; // sparse page // Use specified page length, when next page is sparse page. // Otherwise, calculate size from the offset difference between this and the next page. uint32_t size; if(!pageOffsets[i + 1]) size = pageLengths[i]; else size = pageOffsets[i + 1] - pageOffsets[i]; fseek(file, pageOffsets[i], SEEK_SET); fread(ptr, 1, size, file); ptr += size; } // last page points after page buffer PMPages[ChunksInFile] = ptr; free(pageLengths); free(pageOffsets); fclose(file); }
unsigned BuildCompShape (t_compshape _seg **finalspot) { t_compshape _seg *work; byte far *code; int firstline,lastline,x,y; unsigned firstpix,lastpix,width; unsigned totalsize,pixelofs; unsigned buff; // MM_GetPtr (&(memptr)work,20000); EGAWRITEMODE(0); EGAREADMAP(0); // use ega screen memory for temp buffer EGAMAPMASK(1); buff = screenloc[1]; work = (t_compshape _seg *)(0xa000+(buff+15)/16); // // find the width of the shape // firstline = -1; x=0; do { for (y=0;y<64;y++) if (spotvis[y][x] != BACKGROUNDPIX) { firstline = x; break; } if (++x == 64) Quit ("BuildCompShape: No shape data!"); } while (firstline == -1); lastline = -1; x=63; do { for (y=0;y<64;y++) if (spotvis[y][x] != BACKGROUNDPIX) { lastline = x; break; } x--; } while (lastline == -1); width = lastline-firstline+1; work->width = width; code = (byte far *)&work->codeofs[width]; // // copy all non background pixels to the work space // pixelofs = FP_OFF(code); for (x=firstline;x<=lastline;x++) for (y=0;y<64;y++) if (spotvis[y][x] != BACKGROUNDPIX) *code++ = spotvis[y][x]; // // start compiling the vertical lines // for (x=firstline;x<=lastline;x++) { work->codeofs[x-firstline] = FP_OFF(code); y=0; do { // // scan past black background pixels // while (spotvis[y][x] == BACKGROUNDPIX && y<64) y++; if (y>63) // no more segments break; firstpix = y+1; // +1 because width is before codeofs // // scan past scalable pixels // while (spotvis[y][x] != BACKGROUNDPIX && y<64) y++; if (y>63) lastpix = 65; else lastpix = y+1; // actually one pixel past the last displayed // // compile the scale call // *code++ = 0x8b; // mov bx,[lastpix*2] *code++ = 0x1e; *((unsigned far *)code)++ = lastpix*2; *code++ = 0x8b; // mov cx,[bx] *code++ = 0x0f; *code++ = 0xc6; // move [BYTE bx],0xcb *code++ = 0x07; *code++ = 0xcb; *code++ = 0xa1; // mov ax,[firstpix*2] /************* *((unsigned far *)code)++ = firstpix*2; *code++ = 0x36; // mov [ss:0],ax *code++ = 0xa3; *code++ = 0x00; *code++ = 0x00; *code++ = 0x8e; // mov ds,dx (mov ds,cs) *code++ = 0xda; *code++ = 0xbe; // mov si,OFFSET pixelofs-firstpixel *((unsigned far *)code)++ = pixelofs-firstpix; *code++ = 0xff; // call [DWORD bp] *code++ = 0x5e; *code++ = 0x00; *code++ = 0x8e; // mov ds,[bp+2] *code++ = 0x5e; *code++ = 0x02; *code++ = 0x89; // mov [bx],cx *code++ = 0x0f; pixelofs += (lastpix-firstpix); } while (y<63); // // retf // *code++ = 0xcb; } // // copy the final shape to a properly sized buffer // totalsize = FP_OFF(code); if (totalsize >= (PAGELEN*2)) Quit("BuildCompShape(): Shape is too complex!"); MM_GetPtr ((memptr *)finalspot,totalsize); _fmemcpy ((byte _seg *)(*finalspot),(byte _seg *)work,totalsize); // MM_FreePtr (&(memptr)work); return totalsize; }
bool BAM_Application::HandleMsg(Message* pMsg) { BAM_TeleportPopup *pTeleport; switch(pMsg->type) { case MSG_NOTICE: switch(pMsg->notice.type) { case N_QUIT: return(TRUE); } break; case MSG_EVENT: switch (pMsg->event.type) { case E_KEY_DOWN: switch(pMsg->event.value) { case K_X: #ifndef NDEBUG if(pMsg->event.modifiers & MOD_ALT) pContextMgr->Quit(); #endif break; case K_ESC: Quit(); return(TRUE); #ifndef NDEBUG case K_Z: //saveNum = 1; if(pMono->suspended) pMono->Resume(); else pMono->Suspend(); break; case K_Y: //restoreNum = 1; break; case K_F4: //one screen capture if(!bGlobal.gSnap) { if(!pWorld || (pWorld && bGlobal.storyLine != NETGAME)) { //lets setup for screen snapping (capture) TRACK_MEM("Snap"); pSnap = new Snap; bGlobal.gSnap = pSnap->gSelf; } } //no single shots while snap is toggled on if(!pSnap->snapOn) pSnap->SingleScreen(); //delete snap alloc -now elsewhere //if(bGlobal.gSnap) //{ // ADelete(bGlobal.gSnap); // bGlobal.gSnap = 0; //} return(TRUE); //case K_F6: ////toggle on/off screen snap // //if(!bGlobal.gSnap) //{ // //lets setup for screen snapping (capture) // TRACK_MEM("Snap"); pSnap = new Snap; // bGlobal.gSnap = pSnap->gSelf; //} // //if(pSnap->snapOn) // pSnap->StopSnap(); //else // pSnap->StartSnap(); // return(TRUE); case K_F10: SetFontColors(CI_SKIP,93,90); // teleport TRACK_MEM("teleport"); pTeleport = new BAM_TeleportPopup; pTeleport->Setup(OPTION_SQB,38); return(TRUE); case K_F11: SetFontColors(CI_SKIP,93,90); // RUN CINEMATIC NUMBER? //can only use this from main menu if(bGlobal.roomMgr.curRoomNum == BR_MENU) { bGlobal.roomMgr.prevRoomMode = 0; bGlobal.roomMgr.newRoomMode = 1; TRACK_MEM("telecine"); pTeleport = new BAM_TeleportPopup; pTeleport->Setup(OPTION_SQB,53); } return(TRUE); case K_PRINT_SCREEN: // if (!ki_debugging) // { // #pragma aux ENTER_DEBUG = \ // "int 3"; // ENTER_DEBUG(); // } return(TRUE); #endif } } } return(Context::HandleMsg(pMsg)); }
void ScaleShape (int xcenter, t_compshape _seg *compshape, unsigned scale) { #define MAX_OBJ_SCALE (MAXSCALE) t_compscale _seg *comptable; unsigned width,scalewidth; int x,pixel,lastpixel,pixwidth,min; unsigned far *codehandle, far *widthptr; unsigned badcodeptr; int rightclip; if (!compshape) Quit ("ScaleShape: NULL compshape ptr!"); scale = (scale+1)/2; if (!scale) return; // too far away if (scale>MAX_OBJ_SCALE) scale = MAX_OBJ_SCALE; comptable = scaledirectory[scale]; width = compshape->width; scalewidth = comptable->start[width]; pixel = xcenter - scalewidth/2; lastpixel = pixel+scalewidth-1; if (pixel >= VIEWWIDTH || lastpixel < 0) return; // totally off screen // // scan backwards from the right edge until pixels are visable // rightclip is the first NON VISABLE pixel // if (lastpixel>=VIEWWIDTH-1) rightclip = VIEWWIDTH-1; else rightclip = lastpixel; if (zbuffer[rightclip]>scale) { if (pixel>0) min = pixel; else min = 0; do { if (--rightclip < min) return; // totally covered or before 0 if (zbuffer[rightclip]<=scale) break; } while (1); } rightclip++; // // scan from the left until it is on screen, leaving // [pixel],[pixwidth],[codehandle],and [widthptr] set correctly // *(((unsigned *)&longtemp)+1) = (unsigned)compshape; // seg of shape codehandle = &compshape->codeofs[0]; badcodeptr = compshape->codeofs[width]; widthptr = &comptable->width[0]; asm mov ax,[comptable] asm mov WORD PTR [2],ax // ds:0-4 is used as a far call pointer // by the compiled shapes pixwidth = *widthptr; // scaled width of this pixel while (!pixwidth) { pixwidth = *++widthptr; // find the first visable pixel codehandle++; } if (pixel<0) { do { if (pixel+pixwidth>0) { pixwidth += pixel; pixel = 0; break; } do { pixwidth = *++widthptr; codehandle++; } while (!pixwidth); pixel+=pixwidth; } while (1); } // // scan until it is visable, leaving // [pixel],[pixwidth],[codehandle],and [widthptr] set correctly // do { if (zbuffer[pixel] <= scale) break; // start drawing here pixel++; if (!--pixwidth) { do { pixwidth = *++widthptr; codehandle++; } while (!pixwidth); } } while (1); if (pixel+pixwidth>rightclip) pixwidth = rightclip-pixel; // // draw lines // do // while (1) { // // scale a vertical segment [pixwidth] pixels wide at [pixel] // (unsigned)longtemp = *codehandle; // offset of compiled code if ((unsigned)longtemp == badcodeptr) Quit ("ScaleShape: codehandle past end!"); asm mov bx,[pixel] asm mov di,bx asm shr di,1 asm shr di,1 asm shr di,1 // X in bytes asm add di,[bufferofs] asm and bx,7 asm shl bx,1 asm shl bx,1 asm shl bx,1 asm add bx,[pixwidth] // bx = pixel*8+pixwidth-1 asm dec bx asm push bx asm mov al,BYTE PTR [bitmasks1+bx] asm mov dx,GC_INDEX+1 asm out dx,al // set bit mask register asm mov es,[screenseg] asm push si asm push di asm push bp asm xor bp,bp asm mov dx,[WORD PTR longtemp+2] asm mov ds,[2] asm call ss:[DWORD PTR longtemp] // scale the line of pixels asm mov ax,ss asm mov ds,ax asm pop bp asm pop di asm pop si asm pop bx asm mov al,BYTE PTR [bitmasks2+bx] asm or al,al asm jz nosecond // // draw a second byte for vertical strips that cross two bytes // asm inc di asm mov dx,GC_INDEX+1 asm out dx,al // set bit mask register asm push si asm push di asm push bp asm xor bp,bp asm mov dx,[WORD PTR longtemp+2] asm mov ds,[2] asm call ss:[DWORD PTR longtemp] // scale the line of pixels asm mov ax,ss asm mov ds,ax asm pop bp asm pop di asm pop si // // advance to the next drawn line // nosecond:; if ( (pixel+=pixwidth) == rightclip ) { asm mov WORD PTR [0],0 asm mov WORD PTR [2],0 return; // all done! } do { pixwidth = *++widthptr; codehandle++; } while (!pixwidth); if (pixel+pixwidth > rightclip) pixwidth = rightclip-pixel; } while (1); }
void Application::OnInit() { nuiInit(NULL); uint Width = 0, Height = 0; bool HasSize = false; bool IsFullScreen = false; bool DebugObject = false; bool DebugInfo = false; bool ShowFPS = false; nuiRenderer Renderer = eOpenGL; // nuiRenderer Renderer = eSoftware; // nuiRenderer Renderer = eDirect3D; // Accept NGL default options ParseDefaultArgs(); GetLog().UseConsole(true); GetLog().SetLevel(_T("font"), 100); // Manual if ( (GetArgCount() == 1) && ((!GetArg(0).Compare(_T("-h"))) || (!GetArg(0).Compare(_T("--help")))) ) { NGL_OUT(_T("no params\n")); Quit (0); return; } // Parse args int i = 0; while (i < GetArgCount()) { nglString arg = GetArg(i); if ((!arg.Compare(_T("--size")) || !arg.Compare(_T("-s"))) && ((i+1) < GetArgCount())) { int w, h; std::string str(GetArg(i+1).GetStdString()); sscanf(str.c_str(), "%dx%d", &w, &h); if (w > 0) Width = w; if (h > 0) Height = h; HasSize = true; i++; } else if (!arg.Compare(_T("--showfps")) || !arg.Compare(_T("-fps"))) ShowFPS = true; else if (!arg.Compare(_T("--fullscreen")) || !arg.Compare(_T("-f"))) IsFullScreen = true; else if (!arg.Compare(_T("--debugobject")) || !arg.Compare(_T("-d"))) DebugObject = true; else if (!arg.Compare(_T("--debuginfo")) || !arg.Compare(_T("-i"))) DebugInfo = true; else if (!arg.Compare(_T("--renderer")) || !arg.Compare(_T("-r"))) { arg = GetArg(i+1); if (!arg.Compare(_T("opengl"))) Renderer = eOpenGL; else if (!arg.Compare(_T("direct3d"))) Renderer = eDirect3D; else if (!arg.Compare(_T("software"))) Renderer = eSoftware; i++; } i++; } nuiMainWindow::SetRenderer(Renderer); if (!HasSize) { if (IsFullScreen) { nglVideoMode current_mode; Width = current_mode.GetWidth(); Height = current_mode.GetHeight(); } else { #ifdef NUI_IPHONE Width = 320; Height = 480; #else Width = 800; Height = 600; #endif } } /* Create the nglWindow (and thus a GL context, don't even try to * instantiate the gui (or nglFont) before the nuiWin !) */ nuiContextInfo ContextInfo(nuiContextInfo::StandardContext3D); nglWindowInfo Info; Info.Flags = IsFullScreen ? nglWindow::FullScreen : 0; Info.Width = Width; Info.Height = Height; Info.Pos = nglWindowInfo::ePosCenter; Info.Title = APPLICATION_TITLE; Info.XPos = 0; Info.YPos = 0; mpMainWindow = new MainWindow(ContextInfo,Info, ShowFPS); if ((!mpMainWindow) || (mpMainWindow->GetError())) { if (mpMainWindow) NGL_OUT(_T("Error: cannot create window (%s)\n"), mpMainWindow->GetErrorStr()); Quit (1); return; } mpMainWindow->Acquire(); mpMainWindow->DBG_SetMouseOverInfo(DebugInfo); mpMainWindow->DBG_SetMouseOverObject(DebugObject); mpMainWindow->SetState(nglWindow::eShow); }
void MediaAddonServer::ReadyToRun() { if (!be_roster->IsRunning("application/x-vnd.Be.media-server")) { // the media server is not running, let's quit fprintf(stderr, "The media_server is not running!\n"); Quit(); return; } // the control thread is already running at this point, // so we can talk to the media server and also receive // commands for instantiation ASSERT(fStartup == true); // The very first thing to do is to create the system time source, // register it with the server, and make it the default SYSTEM_TIME_SOURCE BMediaNode *timeSource = new SystemTimeSource; status_t result = fMediaRoster->RegisterNode(timeSource); if (result != B_OK) { fprintf(stderr, "Can't register system time source : %s\n", strerror(result)); debugger("Can't register system time source"); } if (timeSource->ID() != NODE_SYSTEM_TIMESOURCE_ID) debugger("System time source got wrong node ID"); media_node node = timeSource->Node(); result = MediaRosterEx(fMediaRoster)->SetNode(SYSTEM_TIME_SOURCE, &node); if (result != B_OK) debugger("Can't setup system time source as default"); // During startup, first all add-ons are loaded, then all // nodes (flavors) representing physical inputs and outputs // are instantiated. Next, all add-ons that need autostart // will be autostarted. Finally, add-ons that don't have // any active nodes (flavors) will be unloaded. char parameter[32]; size_t parameterLength = sizeof(parameter); bool safeMode = false; if (_kern_get_safemode_option(B_SAFEMODE_SAFE_MODE, parameter, ¶meterLength) == B_OK) { if (!strcasecmp(parameter, "enabled") || !strcasecmp(parameter, "on") || !strcasecmp(parameter, "true") || !strcasecmp(parameter, "yes") || !strcasecmp(parameter, "enable") || !strcmp(parameter, "1")) safeMode = true; } fMonitorHandler = new MonitorHandler(this); AddHandler(fMonitorHandler); BMessage pulse(B_PULSE); fPulseRunner = new BMessageRunner(fMonitorHandler, &pulse, 1000000LL); // the monitor handler needs a pulse to check if add-ons are ready // load dormant media nodes const directory_which directories[] = { B_USER_ADDONS_DIRECTORY, B_COMMON_ADDONS_DIRECTORY, B_SYSTEM_ADDONS_DIRECTORY }; // when safemode, only B_SYSTEM_ADDONS_DIRECTORY is used for (uint32 i = safeMode ? 2 : 0; i < sizeof(directories) / sizeof(directory_which); i++) { BDirectory directory; node_ref nodeRef; BPath path; if (find_directory(directories[i], &path) == B_OK && path.Append("media") == B_OK && directory.SetTo(path.Path()) == B_OK && directory.GetNodeRef(&nodeRef) == B_OK) fMonitorHandler->AddDirectory(&nodeRef); } #ifdef USER_ADDON_PATH node_ref nodeRef; if (entry.SetTo(USER_ADDON_PATH) == B_OK && entry.GetNodeRef(&nodeRef) == B_OK) fMonitorHandler->AddDirectory(&nodeRef); #endif fStartup = false; InfoMap::iterator iterator = fInfoMap.begin(); for (; iterator != fInfoMap.end(); iterator++) _InstantiatePhysicalInputsAndOutputs(iterator->second); for (iterator = fInfoMap.begin(); iterator != fInfoMap.end(); iterator++) _InstantiateAutostartFlavors(iterator->second); for (iterator = fInfoMap.begin(); iterator != fInfoMap.end(); iterator++) _PutAddonIfPossible(iterator->second); server_rescan_defaults_command cmd; SendToServer(SERVER_RESCAN_DEFAULTS, &cmd, sizeof(cmd)); }
int main(int argc, char** argv) { char glutGamemode[32]; const char *cparam_name = "Data/camera_para.dat"; // // Camera configuration. // #ifdef _WIN32 char *vconf = "Data\\WDM_camera_flipV.xml"; #else char *vconf = ""; #endif const char *patt_name = "Data/patt.hiro"; // ---------------------------------------------------------------------------- // Library inits. // glutInit(&argc, argv); // ---------------------------------------------------------------------------- // Hardware setup. // if (!setupCamera(cparam_name, vconf, &gARTCparam)) { fprintf(stderr, "main(): Unable to set up AR camera.\n"); exit(-1); } // ---------------------------------------------------------------------------- // Library setup. // // Set up GL context(s) for OpenGL to draw into. glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH); if (!prefWindowed) { if (prefRefresh) sprintf(glutGamemode, "%ix%i:%i@%i", prefWidth, prefHeight, prefDepth, prefRefresh); else sprintf(glutGamemode, "%ix%i:%i", prefWidth, prefHeight, prefDepth); glutGameModeString(glutGamemode); glutEnterGameMode(); } else { glutInitWindowSize(prefWidth, prefHeight); glutCreateWindow(argv[0]); } // Setup argl library for current context. if ((gArglSettings = arglSetupForCurrentContext()) == NULL) { fprintf(stderr, "main(): arglSetupForCurrentContext() returned error.\n"); exit(-1); } debugReportMode(gArglSettings); glEnable(GL_DEPTH_TEST); arUtilTimerReset(); if (!setupMarker(patt_name, &gPatt_id)) { fprintf(stderr, "main(): Unable to set up AR marker.\n"); Quit(); } // Register GLUT event-handling callbacks. // NB: Idle() is registered by Visibility. glutDisplayFunc(Display); glutReshapeFunc(Reshape); glutVisibilityFunc(Visibility); glutKeyboardFunc(Keyboard); glutMainLoop(); return (0); }
void FindDiags(const ProfPos *PX, unsigned uLengthX, const ProfPos *PY, unsigned uLengthY, DiagList &DL) { if (ALPHA_Amino != g_Alpha) Quit("FindDiags: requires amino acid alphabet"); DL.Clear(); if (uLengthX < 12 || uLengthY < 12) return; // Set A to shorter profile, B to longer const ProfPos *PA; const ProfPos *PB; unsigned uLengthA; unsigned uLengthB; bool bSwap; if (uLengthX < uLengthY) { bSwap = false; PA = PX; PB = PY; uLengthA = uLengthX; uLengthB = uLengthY; } else { bSwap = true; PA = PY; PB = PX; uLengthA = uLengthY; uLengthB = uLengthX; } // Build tuple map for the longer profile, B if (uLengthB < KTUP) Quit("FindDiags: profile too short"); memset(TuplePos, EMPTY, sizeof(TuplePos)); for (unsigned uPos = 0; uPos < uLengthB - KTUP; ++uPos) { const unsigned uTuple = GetTuple(PB, uPos); if (EMPTY == uTuple) continue; TuplePos[uTuple] = uPos; } // Find matches for (unsigned uPosA = 0; uPosA < uLengthA - KTUP; ++uPosA) { const unsigned uTuple = GetTuple(PA, uPosA); if (EMPTY == uTuple) continue; const unsigned uPosB = TuplePos[uTuple]; if (EMPTY == uPosB) continue; // This tuple is found in both profiles unsigned uStartPosA = uPosA; unsigned uStartPosB = uPosB; // Try to extend the match forwards unsigned uEndPosA = uPosA + KTUP - 1; unsigned uEndPosB = uPosB + KTUP - 1; for (;;) { if (uLengthA - 1 == uEndPosA || uLengthB - 1 == uEndPosB) break; const unsigned uAAGroupA = PA[uEndPosA+1].m_uResidueGroup; if (RESIDUE_GROUP_MULTIPLE == uAAGroupA) break; const unsigned uAAGroupB = PB[uEndPosB+1].m_uResidueGroup; if (RESIDUE_GROUP_MULTIPLE == uAAGroupB) break; if (uAAGroupA != uAAGroupB) break; ++uEndPosA; ++uEndPosB; } uPosA = uEndPosA; #if TRACE { Log("Match: A %4u-%4u ", uStartPosA, uEndPosA); for (unsigned n = uStartPosA; n <= uEndPosA; ++n) Log("%c", 'A' + PA[n].m_uResidueGroup); Log("\n"); Log(" B %4u-%4u ", uStartPosB, uEndPosB); for (unsigned n = uStartPosB; n <= uEndPosB; ++n) Log("%c", 'A' + PB[n].m_uResidueGroup); Log("\n"); } #endif const unsigned uLength = uEndPosA - uStartPosA + 1; assert(uEndPosB - uStartPosB + 1 == uLength); if (uLength >= g_uMinDiagLength) { if (bSwap) DL.Add(uStartPosB, uStartPosA, uLength); else DL.Add(uStartPosA, uStartPosB, uLength); } } }
//////////////////////////////////////////////////////////////////////////// // // LoadLIBShape() // int LoadLIBShape(char *SLIB_Filename, char *Filename,struct Shape *SHP) { #define CHUNK(Name) (*ptr == *Name) && \ (*(ptr+1) == *(Name+1)) && \ (*(ptr+2) == *(Name+2)) && \ (*(ptr+3) == *(Name+3)) int RT_CODE; FILE *fp; char CHUNK[5]; char far *ptr; memptr IFFfile = NULL; unsigned long FileLen, size, ChunkLen; int loop; RT_CODE = 1; // Decompress to ram and return ptr to data and return len of data in // passed variable... if (!LoadLIBFile(SLIB_Filename,Filename,&IFFfile)) Quit("Error Loading Compressed lib shape!"); // Evaluate the file // ptr = MK_FP(IFFfile,0); if (!CHUNK("FORM")) goto EXIT_FUNC; ptr += 4; FileLen = *(long far *)ptr; SwapLong((long far *)&FileLen); ptr += 4; if (!CHUNK("ILBM")) goto EXIT_FUNC; ptr += 4; FileLen += 4; while (FileLen) { ChunkLen = *(long far *)(ptr+4); SwapLong((long far *)&ChunkLen); ChunkLen = (ChunkLen+1) & 0xFFFFFFFE; if (CHUNK("BMHD")) { ptr += 8; SHP->bmHdr.w = ((struct BitMapHeader far *)ptr)->w; SHP->bmHdr.h = ((struct BitMapHeader far *)ptr)->h; SHP->bmHdr.x = ((struct BitMapHeader far *)ptr)->x; SHP->bmHdr.y = ((struct BitMapHeader far *)ptr)->y; SHP->bmHdr.d = ((struct BitMapHeader far *)ptr)->d; SHP->bmHdr.trans = ((struct BitMapHeader far *)ptr)->trans; SHP->bmHdr.comp = ((struct BitMapHeader far *)ptr)->comp; SHP->bmHdr.pad = ((struct BitMapHeader far *)ptr)->pad; SwapWord(&SHP->bmHdr.w); SwapWord(&SHP->bmHdr.h); SwapWord(&SHP->bmHdr.x); SwapWord(&SHP->bmHdr.y); ptr += ChunkLen; } else if (CHUNK("BODY")) { ptr += 4; size = *((long far *)ptr); ptr += 4; SwapLong((long far *)&size); SHP->BPR = (SHP->bmHdr.w+7) >> 3; MM_GetPtr(&SHP->Data,size); if (!SHP->Data) goto EXIT_FUNC; movedata(FP_SEG(ptr),FP_OFF(ptr),FP_SEG(SHP->Data),0,size); ptr += ChunkLen; break; } else
ProgNode *ProgressiveAlignE(const SeqVect &v, const Tree &GuideTree, MSA &a) { assert(GuideTree.IsRooted()); #if TRACE Log("GuideTree:\n"); GuideTree.LogMe(); #endif const unsigned uSeqCount = v.Length(); const unsigned uNodeCount = 2*uSeqCount - 1; const unsigned uIterCount = uSeqCount - 1; WEIGHT *Weights = new WEIGHT[uSeqCount]; CalcClustalWWeights(GuideTree, Weights); ProgNode *ProgNodes = new ProgNode[uNodeCount]; unsigned uJoin = 0; unsigned uTreeNodeIndex = GuideTree.FirstDepthFirstNode(); SetProgressDesc("Align node"); do { if (GuideTree.IsLeaf(uTreeNodeIndex)) { if (uTreeNodeIndex >= uNodeCount) Quit("TreeNodeIndex=%u NodeCount=%u\n", uTreeNodeIndex, uNodeCount); ProgNode &Node = ProgNodes[uTreeNodeIndex]; unsigned uId = GuideTree.GetLeafId(uTreeNodeIndex); if (uId >= uSeqCount) Quit("Seq index out of range"); const Seq &s = *(v[uId]); Node.m_MSA.FromSeq(s); Node.m_MSA.SetSeqId(0, uId); Node.m_uLength = Node.m_MSA.GetColCount(); Node.m_Weight = Weights[uId]; // TODO: Term gaps settable Node.m_Prof = ProfileFromMSA(Node.m_MSA); Node.m_EstringL = 0; Node.m_EstringR = 0; #if TRACE Log("Leaf id=%u\n", uId); Log("MSA=\n"); Node.m_MSA.LogMe(); Log("Profile (from MSA)=\n"); ListProfile(Node.m_Prof, Node.m_uLength, &Node.m_MSA); #endif } else { Progress(uJoin, uSeqCount - 1); ++uJoin; const unsigned uMergeNodeIndex = uTreeNodeIndex; ProgNode &Parent = ProgNodes[uMergeNodeIndex]; const unsigned uLeft = GuideTree.GetLeft(uTreeNodeIndex); const unsigned uRight = GuideTree.GetRight(uTreeNodeIndex); if (g_bVerbose) { Log("Align: ("); LogLeafNames(GuideTree, uLeft); Log(") ("); LogLeafNames(GuideTree, uRight); Log(")\n"); } ProgNode &Node1 = ProgNodes[uLeft]; ProgNode &Node2 = ProgNodes[uRight]; #if TRACE Log("AlignTwoMSAs:\n"); #endif AlignTwoProfs( Node1.m_Prof, Node1.m_uLength, Node1.m_Weight, Node2.m_Prof, Node2.m_uLength, Node2.m_Weight, Parent.m_Path, &Parent.m_Prof, &Parent.m_uLength); #if TRACE_LENGTH_DELTA { unsigned L = Node1.m_uLength; unsigned R = Node2.m_uLength; unsigned P = Parent.m_Path.GetEdgeCount(); unsigned Max = L > R ? L : R; unsigned d = P - Max; Log("LD%u;%u;%u;%u\n", L, R, P, d); } #endif PathToEstrings(Parent.m_Path, &Parent.m_EstringL, &Parent.m_EstringR); Parent.m_Weight = Node1.m_Weight + Node2.m_Weight; #if VALIDATE { #if TRACE Log("AlignTwoMSAs:\n"); #endif PWPath TmpPath; AlignTwoMSAs(Node1.m_MSA, Node2.m_MSA, Parent.m_MSA, TmpPath); ProfPos *P1 = ProfileFromMSA(Node1.m_MSA, true); ProfPos *P2 = ProfileFromMSA(Node2.m_MSA, true); unsigned uLength = Parent.m_MSA.GetColCount(); ProfPos *TmpProf = ProfileFromMSA(Parent.m_MSA, true); #if TRACE Log("Node1 MSA=\n"); Node1.m_MSA.LogMe(); Log("Node1 prof=\n"); ListProfile(Node1.m_Prof, Node1.m_MSA.GetColCount(), &Node1.m_MSA); Log("Node1 prof (from MSA)=\n"); ListProfile(P1, Node1.m_MSA.GetColCount(), &Node1.m_MSA); AssertProfsEq(Node1.m_Prof, Node1.m_uLength, P1, Node1.m_MSA.GetColCount()); Log("Node2 prof=\n"); ListProfile(Node2.m_Prof, Node2.m_MSA.GetColCount(), &Node2.m_MSA); Log("Node2 MSA=\n"); Node2.m_MSA.LogMe(); Log("Node2 prof (from MSA)=\n"); ListProfile(P2, Node2.m_MSA.GetColCount(), &Node2.m_MSA); AssertProfsEq(Node2.m_Prof, Node2.m_uLength, P2, Node2.m_MSA.GetColCount()); TmpPath.AssertEqual(Parent.m_Path); Log("Parent MSA=\n"); Parent.m_MSA.LogMe(); Log("Parent prof=\n"); ListProfile(Parent.m_Prof, Parent.m_uLength, &Parent.m_MSA); Log("Parent prof (from MSA)=\n"); ListProfile(TmpProf, Parent.m_MSA.GetColCount(), &Parent.m_MSA); #endif // TRACE AssertProfsEq(Parent.m_Prof, Parent.m_uLength, TmpProf, Parent.m_MSA.GetColCount()); delete[] P1; delete[] P2; delete[] TmpProf; } #endif // VALIDATE Node1.m_MSA.Clear(); Node2.m_MSA.Clear(); // Don't delete profiles, may need them for tree refinement. //delete[] Node1.m_Prof; //delete[] Node2.m_Prof; //Node1.m_Prof = 0; //Node2.m_Prof = 0; } uTreeNodeIndex = GuideTree.NextDepthFirstNode(uTreeNodeIndex); } while (NULL_NEIGHBOR != uTreeNodeIndex); ProgressStepsDone(); if (g_bBrenner) MakeRootMSABrenner((SeqVect &) v, GuideTree, ProgNodes, a); else MakeRootMSA(v, GuideTree, ProgNodes, a); #if VALIDATE { unsigned uRootNodeIndex = GuideTree.GetRootNodeIndex(); const ProgNode &RootProgNode = ProgNodes[uRootNodeIndex]; AssertMSAEq(a, RootProgNode.m_MSA); } #endif delete[] Weights; return ProgNodes; }
//-------------------------------------------------------------------------- // BLoad() -- THIS HAS NOT BEEN FULLY TESTED! // // NOTICE : This version of BLOAD is compatable with JAMPak V3.0 and the // new fileformat... //-------------------------------------------------------------------------- unsigned long BLoad(char *SourceFile, memptr *DstPtr) { int handle; memptr SrcPtr; unsigned long i, j, k, r, c; word flags; byte Buffer[8]; unsigned long SrcLen,DstLen; struct CMP1Header CompHeader; boolean Compressed = false; memset((void *)&CompHeader,0,sizeof(struct CMP1Header)); // // Open file to load.... // if ((handle = open(SourceFile, O_RDONLY|O_BINARY)) == -1) return(0); // // Look for JAMPAK headers // read(handle,Buffer,4); if (!strncmp(Buffer,COMP,4)) { // // Compressed under OLD file format // Compressed = true; SrcLen = Verify(SourceFile); read(handle,(void *)&CompHeader.OrginalLen,4); CompHeader.CompType = ct_LZW; MM_GetPtr(DstPtr,CompHeader.OrginalLen); if (!*DstPtr) return(0); } else if (!strncmp(Buffer,CMP1,4)) { // // Compressed under new file format... // Compressed = true; SrcLen = Verify(SourceFile); read(handle,(void *)&CompHeader,sizeof(struct CMP1Header)); MM_GetPtr(DstPtr,CompHeader.OrginalLen); if (!*DstPtr) return(0); } else DstLen = Verify(SourceFile); // // Load the file in memory... // if (Compressed) { DstLen = CompHeader.OrginalLen; if ((MM_TotalFree() < SrcLen) && (CompHeader.CompType)) { if (!InitBufferedIO(handle,&lzwBIO)) Quit("No memory for buffered I/O."); switch (CompHeader.CompType) { #if LZW_SUPPORT case ct_LZW: lzwDecompress(&lzwBIO,MK_FP(*DstPtr,0),CompHeader.OrginalLen,(SRC_BFILE|DEST_MEM)); break; #endif #if LZH_SUPPORT case ct_LZH: lzhDecompress(&lzwBIO,MK_FP(*DstPtr,0),CompHeader.OrginalLen,CompHeader.CompressLen,(SRC_BFILE|DEST_MEM)); break; #endif default: Quit("BLoad() - Unrecognized/Supported compression"); break; } FreeBufferedIO(&lzwBIO); } else { CA_LoadFile(SourceFile,&SrcPtr); switch (CompHeader.CompType) { #if LZW_SUPPORT case ct_LZW: lzwDecompress(MK_FP(SrcPtr,8),MK_FP(*DstPtr,0),CompHeader.OrginalLen,(SRC_MEM|DEST_MEM)); break; #endif #if LZH_SUPPORT case ct_LZH: lzhDecompress(MK_FP(SrcPtr,8),MK_FP(*DstPtr,0),CompHeader.OrginalLen,CompHeader.CompressLen,(SRC_MEM|DEST_MEM)); break; #endif default: Quit("BLoad() - Unrecognized/Supported compression"); break; } MM_FreePtr(&SrcPtr); } } else CA_LoadFile(SourceFile,DstPtr); close(handle); return(DstLen); }
char *ReadAFA(FILE *f, int *ptrSeqLength, int *ptrSeqCount) { rewind(f); int FileSize = GetFileSize(f); int BufferSize = FileSize; char *Buffer = all(char, BufferSize); char prev_c = '\n'; bool InLabel = false; int Pos = 0; int SeqStart = 0; int SeqCount = 0; int SeqLength; for (;;) { int c = fgetc(f); if (EOF == c) { if (feof(f)) break; Quit("Stream error"); } if (InLabel) { if (c == '\r') continue; if ('\n' == c) InLabel = false; } else { if ('>' == c && '\n' == prev_c) { int ThisSeqLength = Pos - SeqStart; if (0 == SeqCount) ; else if (1 == SeqCount) SeqLength = ThisSeqLength; else if (SeqCount > 1) { if (SeqLength != ThisSeqLength) Quit("ReadAFA: sequence lengths differ %d %d", SeqLength, ThisSeqLength); } ++SeqCount; SeqStart = Pos; InLabel = true; } else if (!isspace(c)) { if (Pos >= BufferSize) Quit("ReadAFA: buffer too small"); Buffer[Pos++] = (c); } } prev_c = c; } int ThisSeqLength = Pos - SeqStart; if (0 == SeqCount) SeqLength = ThisSeqLength; else { if (SeqLength != ThisSeqLength) Quit("ReadAFA: sequence lengths differ %d %d", SeqLength, ThisSeqLength); } *ptrSeqCount = SeqCount; *ptrSeqLength = SeqLength; if (Pos != SeqCount*SeqLength) Quit("ReadAFA: Internal error"); return Buffer; }
int main( int argc, char **argv ) { /* Flags to pass to SDL_SetVideoMode */ int videoFlags; /* main loop variable */ int done = FALSE; /* used to collect events */ SDL_Event event; /* this holds some info about our display */ const SDL_VideoInfo *videoInfo; /* whether or not the window is active */ int isActive = TRUE; /* initialize SDL */ if ( SDL_Init( SDL_INIT_VIDEO ) < 0 ) { fprintf( stderr, "Video initialization failed: %s\n", SDL_GetError( ) ); Quit( 1 ); } /* Fetch the video info */ videoInfo = SDL_GetVideoInfo( ); if ( !videoInfo ) { fprintf( stderr, "Video query failed: %s\n", SDL_GetError( ) ); Quit( 1 ); } /* the flags to pass to SDL_SetVideoMode */ videoFlags = SDL_OPENGL; /* Enable OpenGL in SDL */ videoFlags |= SDL_GL_DOUBLEBUFFER; /* Enable double buffering */ videoFlags |= SDL_HWPALETTE; /* Store the palette in hardware */ videoFlags |= SDL_RESIZABLE; /* Enable window resizing */ /* This checks to see if surfaces can be stored in memory */ if ( videoInfo->hw_available ) videoFlags |= SDL_HWSURFACE; else videoFlags |= SDL_SWSURFACE; /* This checks if hardware blits can be done */ if ( videoInfo->blit_hw ) videoFlags |= SDL_HWACCEL; /* Sets up OpenGL double buffering */ SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); /* get a SDL surface */ surface = SDL_SetVideoMode( SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP, videoFlags ); /* Verify there is a surface */ if ( !surface ) { fprintf( stderr, "Video mode set failed: %s\n", SDL_GetError( ) ); Quit( 1 ); } /* initialize OpenGL */ initGL( ); /* resize the initial window */ resizeWindow( SCREEN_WIDTH, SCREEN_HEIGHT ); /* wait for events */ while ( !done ) { /* handle the events in the queue */ while ( SDL_PollEvent( &event ) ) { switch( event.type ) { case SDL_ACTIVEEVENT: /* Something's happend with our focus * If we lost focus or we are iconified, we * shouldn't draw the screen */ if ( event.active.gain == 0 ) isActive = FALSE; else isActive = TRUE; break; case SDL_VIDEORESIZE: #if 0 /* handle resize event */ surface = SDL_SetVideoMode( event.resize.w, event.resize.h, 16, videoFlags ); if ( !surface ) { fprintf( stderr, "Could not get a surface after resize: %s\n", SDL_GetError( ) ); Quit( 1 ); } resizeWindow( event.resize.w, event.resize.h ); #endif break; case SDL_KEYDOWN: /* handle key presses */ handleKeyPress( &event.key.keysym ); break; case SDL_QUIT: /* handle quit requests */ done = TRUE; break; default: break; } } /* draw the scene */ if ( isActive ) drawGLScene( ); } /* clean ourselves up and exit */ Quit( 0 ); /* Should never get here */ return( 0 ); }