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 );
}
