/*=macfunc ENDWHILE
*
* what: Terminate the @code{WHILE} Template Block
* in-context:
*
* desc:
* This macro ends the @code{WHILE} function template block.
* For a complete description @xref{WHILE}.
=*/
tMacro*
mFunc_While(tTemplate* pT, tMacro* pMac)
{
tMacro* pRet = pT->aMacros + pMac->endIndex;
int ct = 0;
if (OPT_VALUE_TRACE >= TRACE_BLOCK_MACROS)
fprintf(pfTrace, TRACE_FN_WHILE_START,
pCurTemplate->pzTemplText + pCurMacro->ozText,
pT->pzTplFile, pMac->lineNo);
for (;;) {
pCurTemplate = pT;
pCurMacro = pMac;
if (! eval_true())
break;
ct++;
generateBlock(pT, pMac+1, pT->aMacros + pMac->sibIndex);
}
if (OPT_VALUE_TRACE >= TRACE_BLOCK_MACROS) {
fprintf(pfTrace, TRACE_FN_WHILE_END, ct);
if (OPT_VALUE_TRACE == TRACE_EVERYTHING)
fprintf(pfTrace, TAB_FILE_LINE_FMT, pT->pzTplFile, pMac->lineNo);
}
return pRet;
}
void dMap::generateMap()
{
for(int i=0; i<4; i++)
mOpenTop[0][i] = 0;
for(int i=1; i<3; i++)
{
for(int j=0; j<4; j++)
mOpenTop[i][j] = mOpenBottom[i-1][j] = random(0,1);
if(!mOpenTop[i][0] && !mOpenTop[i][1] && !mOpenTop[i][2] && !mOpenTop[i][3])
i--;
}
do
{
for(int j=0; j<3; j++)
mOpenBottom[2][j] = random(0,1);
} while(!mOpenBottom[2][0] && !mOpenBottom[2][1] && !mOpenBottom[2][2] && !mOpenBottom[2][3]);
/*for(int i=0; i<4; i++)
{
mOpenTop[0][i] = 0;
mOpenBottom[2][i] = random(0,1);
for(int j=1; j<3; j++)
mOpenTop[j][i] = mOpenBottom[j-1][i] = random(0,1);
}*/
for(int i=0; i<3; i++)
generateBlock(i);
}
/*=macfunc INCLUDE
*
* what: Read in and emit a template block
* handler_proc:
* load_proc:
*
* desc:
*
* The entire contents of the named file is inserted at this point.
* The contents of the file are processed for macro expansion. The
* arguments are eval-ed, so you may compute the name of the file to
* be included. The included file must not contain any incomplete
* function blocks. Function blocks are template text beginning with
* any of the macro functions @samp{CASE}, @samp{DEFINE}, @samp{FOR},
* @samp{IF} and @samp{WHILE}; extending through their respective
* terminating macro functions.
=*/
tMacro*
mFunc_Include(tTemplate* pT, tMacro* pMac)
{
tTemplate * pNewTpl;
ag_bool needFree;
char const * pzFile = evalExpression(&needFree);
tMacro* pM;
if (*pzFile != NUL) {
pNewTpl = loadTemplate(pzFile, pT->pzTplFile);
/*
* Strip off trailing white space from included templates
*/
pM = pNewTpl->aMacros + (pNewTpl->macroCt - 1);
if (pM->funcCode == FTYP_TEXT) {
char* pz = pNewTpl->pzTemplText + pM->ozText;
char* pzE = pz + strlen(pz);
while ((pzE > pz) && IS_WHITESPACE_CHAR(pzE[-1])) --pzE;
/*
* IF there is no text left, remove the macro entirely
*/
if (pz == pzE)
pNewTpl->macroCt--;
else *pzE = NUL;
}
if (OPT_VALUE_TRACE > TRACE_DEBUG_MESSAGE) {
fprintf(pfTrace, TRACE_FN_INC_TPL, pNewTpl->pzTplFile);
if (OPT_VALUE_TRACE == TRACE_EVERYTHING)
fprintf(pfTrace, TRACE_FN_INC_LINE, pCurTemplate->pzTplFile,
pMac->lineNo);
}
generateBlock(pNewTpl, pNewTpl->aMacros,
pNewTpl->aMacros + pNewTpl->macroCt);
unloadTemplate(pNewTpl);
pCurTemplate = pT;
}
if (needFree)
AGFREE((void*)pzFile);
return pMac + 1;
}
/*=macfunc ENDIF
*
* what: Terminate the @code{IF} Template Block
* in-context:
*
* desc:
* This macro ends the @code{IF} function template block.
* For a complete description @xref{IF}.
=*/
tMacro*
mFunc_If(tTemplate* pT, tMacro* pMac)
{
tMacro* pRet = pT->aMacros + pMac->endIndex;
tMacro* pIf = pMac;
do {
/*
* The current macro becomes the 'ELIF' or 'ELSE' macro
*/
pCurMacro = pMac;
/*
* 'ELSE' is equivalent to 'ELIF true'
*/
if ( (pMac->funcCode == FTYP_ELSE)
|| eval_true()) {
if (OPT_VALUE_TRACE >= TRACE_BLOCK_MACROS) {
fprintf(pfTrace, TRACE_FN_IF, (pMac->funcCode == FTYP_ELSE)
? FN_IF_ELSE : pT->pzTemplText + pMac->ozText,
pMac->lineNo);
if (OPT_VALUE_TRACE == TRACE_EVERYTHING)
fprintf(pfTrace, TAB_FILE_LINE_FMT,
pCurTemplate->pzTplFile, pIf->lineNo);
}
generateBlock(pT, pMac+1, pT->aMacros + pMac->sibIndex);
break;
}
pMac = pT->aMacros + pMac->sibIndex;
} while (pMac < pRet);
if ((OPT_VALUE_TRACE >= TRACE_BLOCK_MACROS) && (pMac >= pRet)) {
fprintf(pfTrace, TRACE_FN_IF_NOTHING,
pCurTemplate->pzTemplText + pCurMacro->ozText);
if (OPT_VALUE_TRACE == TRACE_EVERYTHING)
fprintf(pfTrace, TAB_FILE_LINE_FMT,
pCurTemplate->pzTplFile, pIf->lineNo);
}
return pRet;
}
/*=macfunc ESAC
*
* what: Terminate the @code{CASE} Template Block
* in-context:
*
* desc:
* This macro ends the @code{CASE} function template block.
* For a complete description, @xref{CASE}.
=*/
tMacro*
mFunc_Case(tTemplate* pT, tMacro* pMac)
{
typedef tSuccess (t_match_proc)(char const *, char const *);
/*
* There are only 15 procedures because the case insenstive matching
* get mapped into the previous four. The last three are "match always",
* "match if a value was found" "match if no value found".
*/
static t_match_proc * const match_procs[] = {
&Select_Compare_Full,
&Select_Compare_End,
&Select_Compare_Start,
&Select_Compare,
&Select_Equivalent_Full,
&Select_Equivalent_End,
&Select_Equivalent_Start,
&Select_Equivalent,
&Select_Match_Full,
&Select_Match_End,
&Select_Match_Start,
&Select_Match,
&Select_Match_Always,
&Select_Match_Existence,
&Select_Match_NonExistence
};
static char const * const match_names[] = {
"COMPARE_FULL",
"COMPARE_END",
"COMPARE_START",
"CONTAINS",
"EQUIVALENT_FULL",
"EQUIVALENT_END",
"EQUIVALENT_START",
"EQUIV_CONTAINS",
"MATCH_FULL",
"MATCH_END",
"MATCH_START",
"MATCH_WITHIN",
"MATCH_ALWAYS",
"MATCH_EXISTENCE",
"MATCH_NONEXISTENCE"
};
tMacro* pEnd = pT->aMacros + pMac->endIndex;
ag_bool needFree;
char const * pzSampleText = evalExpression(&needFree);
/*
* Search through the selection clauses until we either
* reach the end of the list for this CASE macro, or we match.
*/
for (;;) {
tSuccess mRes;
pMac = pT->aMacros + pMac->sibIndex;
if (pMac >= pEnd) {
if (OPT_VALUE_TRACE >= TRACE_BLOCK_MACROS) {
fprintf(pfTrace, "CASE string `%s' did not match\n",
pzSampleText);
if (OPT_VALUE_TRACE == TRACE_EVERYTHING)
fprintf(pfTrace, zFileLine, pCurTemplate->pzTplFile,
pMac->lineNo);
}
break;
}
/*
* The current macro becomes the selected selection macro
*/
pCurMacro = pMac;
mRes = (*(match_procs[pMac->funcCode & 0x0F])
)(pzSampleText, pT->pzTemplText + pMac->ozText);
/*
* IF match, THEN generate and stop looking for a match.
*/
if (SUCCEEDED(mRes)) {
if (OPT_VALUE_TRACE >= TRACE_BLOCK_MACROS) {
fprintf(pfTrace, "CASE string `%s' %s matched `%s'\n",
pzSampleText,
match_names[pMac->funcCode & 0x0F],
pT->pzTemplText + pMac->ozText);
if (OPT_VALUE_TRACE == TRACE_EVERYTHING)
fprintf(pfTrace, zFileLine, pCurTemplate->pzTplFile,
pMac->lineNo);
}
generateBlock(pT, pMac + 1, pT->aMacros + pMac->sibIndex);
break;
}
else if (OPT_VALUE_TRACE == TRACE_EVERYTHING) {
fprintf(pfTrace, "CASE no match: `%s' %s vs. `%s'\n",
pzSampleText,
match_names[pMac->funcCode & 0x0F],
pT->pzTemplText + pMac->ozText);
}
}
if (needFree)
AGFREE((void*)pzSampleText);
return pEnd;
}
LOCAL void
processTemplate(tTemplate* pTF)
{
forInfo.fi_depth = 0;
/*
* IF the template file does not specify any output suffixes,
* THEN we will generate to standard out with the suffix set to zNoSfx.
* With output going to stdout, we don't try to remove output on errors.
*/
if (pOutSpecList == NULL) {
do_stdout_tpl(pTF);
return;
}
do {
tOutSpec* pOS = pOutSpecList;
/*
* We cannot be in Scheme processing. We've either just started
* or we've made a long jump from our own code. If we've made a
* long jump, we've printed a message that is sufficient and we
* don't need to print any scheme expressions.
*/
pzLastScheme = NULL;
/*
* HOW was that we got here?
*/
switch (setjmp(fileAbort)) {
case SUCCESS:
if (OPT_VALUE_TRACE >= TRACE_EVERYTHING) {
fprintf(pfTrace, PROC_TPL_START, pOS->zSuffix);
fflush(pfTrace);
}
/*
* Set the output file name buffer.
* It may get switched inside open_output.
*/
open_output(pOS);
memcpy(&fpRoot, pCurFp, sizeof(fpRoot));
AGFREE(pCurFp);
pCurFp = &fpRoot;
pzCurSfx = pOS->zSuffix;
currDefCtx = rootDefCtx;
pCurFp->flags &= ~FPF_FREE;
pCurFp->pPrev = NULL;
generateBlock(pTF, pTF->aMacros, pTF->aMacros + pTF->macroCt);
do {
out_close(AG_FALSE); /* keep output */
} while (pCurFp->pPrev != NULL);
break;
case PROBLEM:
/*
* We got here by a long jump. Close/purge the open files.
*/
do {
out_close(AG_TRUE); /* discard output */
} while (pCurFp->pPrev != NULL);
pzLastScheme = NULL; /* "problem" means "drop current output". */
break;
default:
fprintf(pfTrace, PROC_TPL_BOGUS_RET, pzOopsPrefix);
pzOopsPrefix = zNil;
/* FALLTHROUGH */
case FAILURE:
/*
* We got here by a long jump. Close/purge the open files.
*/
do {
out_close(AG_TRUE); /* discard output */
} while (pCurFp->pPrev != NULL);
/*
* On failure (or unknown jump type), we quit the program, too.
*/
procState = PROC_STATE_ABORTING;
do pOS = nextOutSpec(pOS);
while (pOS != NULL);
exit(EXIT_FAILURE);
}
pOutSpecList = nextOutSpec(pOS);
} while (pOutSpecList != NULL);
}
/**
* The template output goes to stdout. Perhaps because output
* is for a CGI script. In any case, this case must be handled
* specially.
*/
static void
do_stdout_tpl(tTemplate * pTF)
{
char const * pzRes;
SCM res;
pzLastScheme = NULL; /* We cannot be in Scheme processing */
switch (setjmp (fileAbort)) {
case SUCCESS:
break;
case PROBLEM:
if (*pzOopsPrefix != NUL) {
fprintf(stdout, DO_STDOUT_TPL_ABANDONED, pzOopsPrefix);
pzOopsPrefix = zNil;
}
fclose(stdout);
return;
default:
fprintf(stdout, DO_STDOUT_TPL_BADR, pzOopsPrefix);
case FAILURE:
exit(EXIT_FAILURE);
}
pzCurSfx = DO_STDOUT_TPL_NOSFX;
currDefCtx = rootDefCtx;
pCurFp = &fpRoot;
fpRoot.pFile = stdout;
fpRoot.pzOutName = DO_STDOUT_TPL_STDOUT;
fpRoot.flags = FPF_NOUNLINK | FPF_STATIC_NM;
if (OPT_VALUE_TRACE >= TRACE_EVERYTHING)
fputs(DO_STDOUT_TPL_START_STD, pfTrace);
/*
* IF there is a CGI prefix for error messages,
* THEN divert all output to a temporary file so that
* the output will be clean for any error messages we have to emit.
*/
if (*pzOopsPrefix == NUL)
generateBlock(pTF, pTF->aMacros, pTF->aMacros + pTF->macroCt);
else {
(void)ag_scm_out_push_new(SCM_UNDEFINED);
generateBlock(pTF, pTF->aMacros, pTF->aMacros + pTF->macroCt);
/*
* Read back in the spooled output. Make sure it starts with
* a content-type: prefix. If not, we supply our own HTML prefix.
*/
res = ag_scm_out_pop(SCM_BOOL_T);
pzRes = AG_SCM_CHARS(res);
/* 13: "content-type:" */
if (strneqvcmp(pzRes, DO_STDOUT_TPL_CONTENT, 13) != 0)
fputs(DO_STDOUT_TPL_CONTENT, stdout);
fwrite(pzRes, AG_SCM_STRLEN(res), (size_t)1, stdout);
}
fclose(stdout);
}
QList<PreferencePanelBlock> KNPreferencePanelData::getPanelData(
int panelIndex)
{
//Prepare the panel data and block data cache.
QList<PreferencePanelBlock> panelData;
PreferencePanelBlock block;
//Check the panel.
switch(panelIndex)
{
case PanelGeneral:
{
#ifdef Q_OS_WIN
//System Tray Settings.
block=generateBlock(tr("System Tray Icon"));
addItem(block, tr("Minimize to system tray"),
"User/Global/SystemTray/MinimizeToTray", false, TypeBoolean,
tr("When click the minimize button of the window, Mu won't "
"simply minimize the main window to task bar but minimize "
"to the system tray.\n"
"When click the icon in the system tray, Mu will pop up "
"back."),
false);
addItem(block, tr("Close to system tray"),
"User/Global/SystemTray/CloseToTray", false, TypeBoolean,
tr("When click the close button of the window, Mu won't quit "
"but minimize to the system tray.\n"
"When click the icon in the system tray, Mu will pop up "
"back."),
false);
panelData.append(block);
#endif
//Appearance settings.
block=generateBlock(tr("Appearance"));
addFontItem(block, tr("Application font"),
"User/Global/ApplicationFont", QApplication::font(),
tr("This option will change the font used for the whole "
"application.\n"
"This option will be applied after the application "
"restarted."), false, false, false);
addItem(block, tr("Show status bar"),
"User/Global/Appearance/ShowStatusBar", true, TypeBoolean,
tr("Show the status bar at the top right corner."), false);
panelData.append(block);
//Behaviour settings.
block=generateBlock(tr("Behaviour"), true);
addIntItem(block, tr("Search delay (ms)"),
"User/Global/Behaviour/SearchDelay", 150,
tr("Mu will start to search once user change the content of "
"the search box.\nWhen set the delay larger than 0ms, Mu "
"will not start to search if user change the text less "
"than the delay duration."),
0, 500, false);
panelData.append(block);
//Library settings.
block=generateBlock(tr("Library"));
addItem(block, tr("Ignore CUE data file"),
"User/Music/MusicLibrary/IgnoreCueData", true, TypeBoolean,
tr("When adding the data file of one CUE file, "
"ignore the data file."), false);
addItem(block, tr("Category by album artist"),
"User/Music/MusicLibrary/UseAlbumArt", true, TypeBoolean,
tr("When category the album, use the album artist metadata "
"field instead of statistic all the artists.\n"
"This option will be applied after the application "
"restarted."), true);
panelData.append(block);
break;
}
case PanelPlayback:
{
//Playing parameters.
block=generateBlock(tr("Output Parameter"));
#ifdef Q_OS_WIN64
addItem(block, tr("Use exclusive mode WASAPI"),
"System/Backend/WASAPI", false, TypeBoolean,
tr("Using WASAPI with exclusive mode instead of DirectX for "
"sound output.\nWhen this feature is enabled, the output "
"sample rate will be changed to the sample rate of the real "
"device.\nWhen this feature is enabled, all the music "
"preview feature will be disabled.\nThis option will be "
"applied after the application restarted."), false);
#endif
addItem(block, tr("Use 32-bit float point"),
"System/Backend/Float", true, TypeBoolean,
tr("Produce 32-bit floating-point output.\nWDM drivers are "
"required to use this feature in Windows.\nThis option will"
" be applied after the application restarted."), false);
addItem(block, tr("Use Buffer"),
"System/Backend/Buffer", true, TypeBoolean,
tr("Enable the playback buffering.\nA playing music is "
"normally asked to render data to its playback buffer in "
"advance to produce the final signal that is given to the "
"output device.\nWhen this option is off, buffering is "
"skipped and the playing thread will only be asked to "
"produce data as it is needed during the generation of the "
"output data.\nThis option will"
" be applied after the application restarted."), false);
addIntItem(block, tr("Buffer Length"),
"System/Backend/BufferLength", 500,
tr("The buffer length in milliseconds.\n"
"Increasing the length, decreases the chance of the "
"sound possibly breaking-up on slower computers, \nbut "
"also increases the latency for DSP/FX.\nThis option "
"will be applied after the application restarted."),
10, 5000, false);
addItem(block, tr("Force Stereo Output"),
"System/Backend/Stero", false, TypeBoolean,
tr("Limit the output to stereo, saving some CPU if the device "
"has more speakers available.\nThis option will be applied "
"after the application restarted."), true);
addItem(block, tr("Output Device"),
"System/Backend/OutputDevice", QVariant(), TypeAudioDevice,
tr("Select the audio output device for music playing.\nThis "
"option will be applied after the application restarted."),
false);
QStringList sampleRates;
QString defaultSampleRate=tr("Use Device Default Sample Rate");
sampleRates << defaultSampleRate << "8000" << "11025" << "22050"
<< "32000" << "44100" << "47250" << "48000" << "50000"
<< "50400" << "96000" << "192000";
addComboItem(block, tr("Sample Rate (Hz)"),
"System/Backend/SampleRate", defaultSampleRate,
tr("This option will change the output sample rate of the "
"playback backend.\nThis option will be applied after "
"the application restarted."),
sampleRates, false, true);
panelData.append(block);
//Playing parameters.
block=generateBlock(tr("Player Parameters"));
addIntItem(block, tr("Volume Level (%)"),
"User/Backend/VolumeLevel", 10,
tr("Mu supports changing volume via shortcut key or mouse "
"scroll wheel.\nThis option could change the volume size "
"increase or decrease for each shortcut pressing and "
"wheel scrolling.\nThe minimum size is 1%, the maximum "
"size is 20%."),
1, 20, false);
panelData.append(block);
break;
}
case PanelLyrics:
{
//Header lyrics.
block=generateBlock(tr("Header Lyrics"));
addFontItem(block, tr("Header lyrics font"),
"User/Music/MusicHeaderPlayer/Lyrics/Font",
QApplication::font(),
tr("This option will change the font used on the header "
"player lyrics."), true, true, false);
addIntItem(block, tr("Header lyrics spacing"),
"User/Music/MusicHeaderPlayer/Lyrics/Spacing", 2,
tr("This option will change the spacing of the text line on "
"the header player lyrics."), 1, 20, true);
panelData.append(block);
//Online lyrics.
block=generateBlock(tr("Online Lyrics"));
addItem(block, tr("Allow downloading lyrics"),
"User/Music/Lyrics/Online/Enable", true, TypeBoolean,
tr("If there is no lyrics existed in the lyrics search folder,"
"\nallows Mu to download lyrics from the Internet."), false);
addItem(block, tr("Combine translation"),
"User/Music/Lyrics/Online/CombineTranslation", false,
TypeBoolean,
tr("Some lyrics downloader will provide translated version. \n"
"This option will allow Mu to combine the translated version"
" and the raw lyrics into a single file."), false);
panelData.append(block);
break;
}
case PanelShortcuts:
{
//Global shortcut settings.
block=generateBlock(tr("Global Shortcut"));
addItem(block, tr("Use global shortcut"),
"User/Shortcut/Global", false, TypeBoolean,
tr("Allow the shortcut key bindings to be triggered system "
"wide."), false);
panelData.append(block);
//Main window controls.
block=generateBlock(tr("Window Controls"));
addItem(block, tr("Full Screen"),
"User/Shortcut/FullScreen",
QVariant::fromValue(QKeySequence(QKeySequence::FullScreen)),
TypeShortcut,
tr("This shortcut will be used to control the shortcut for "
"entering or exiting the full screen state."), false);
panelData.append(block);
//Playback controls.
block=generateBlock(tr("Playing Controls"));
addItem(block, tr("Play and Pause"),
"User/Shortcut/PlayNPause",
QVariant::fromValue(QKeySequence(Qt::Key_F8,
Qt::Key_MediaTogglePlayPause)),
TypeShortcut,
tr("This shortcut will be used in the whole application to "
"play or pause the current playing music."), false);
addItem(block, tr("Previous Song"),
"User/Shortcut/Previous",
QVariant::fromValue(QKeySequence(Qt::Key_F7,
Qt::Key_MediaPrevious)),
TypeShortcut,
tr("This shortcut will be used in the whole application to "
"switch the current playing music to the previous song."),
false);
addItem(block, tr("Next Song"),
"User/Shortcut/Next",
QVariant::fromValue(QKeySequence(Qt::Key_F9,
Qt::Key_MediaNext)),
TypeShortcut,
tr("This shortcut will be used in the whole application to "
"switch the current playing music to the next song."),
false);
panelData.append(block);
//Volume controls.
block=generateBlock(tr("Volume Controls"));
addItem(block, tr("Mute"),
"User/Shortcut/Mute",
QVariant::fromValue(QKeySequence()),
TypeShortcut,
tr("This shortcut will be used in the whole application to "
"enter and exit the mute state."), false);
addItem(block, tr("Volume Up"),
"User/Shortcut/VolumeUp",
QVariant::fromValue(QKeySequence()),
TypeShortcut,
tr("This shortcut will be used in the whole application to "
"increase amount of volume."), false);
addItem(block, tr("Volume Down"),
"User/Shortcut/VolumeDown",
QVariant::fromValue(QKeySequence()),
TypeShortcut,
tr("This shortcut will be used in the whole application to "
"decrease amount of volume."), false);
panelData.append(block);
break;
}
case PanelFileAsso:
{
//For some quick controls.
block=generateBlock(tr("Auto Set File Types Association"));
panelData.append(block);
block=generateBlock(tr("Lossless Compressed File Types"));
addFileTypeItem(block, "ape", "", QVariant(), "",
".ape", "org.kreogist.monkeysaudio-format", false);
addFileTypeItem(block, "caf", "", QVariant(), "",
".caf", "com.apple.coreaudio-format", false);
addFileTypeItem(block, "dsd", "", QVariant(), "",
".dsd", "org.kreogist.dsd-format", false);
addFileTypeItem(block, "flac", "", QVariant(), "",
".flac", "org.kreogist.flac-format", false);
addFileTypeItem(block, "tta", "", QVariant(), "",
".tta", "org.kreogist.trueaudio-format", false);
addFileTypeItem(block, "wav", "", QVariant(), "",
".wav", "com.microsoft.waveform-audio", false);
addFileTypeItem(block, "wv", "", QVariant(), "",
".wv", "org.kreogist.wavpack-audio", false);
panelData.append(block);
block=generateBlock(tr("Lossy Compressed File Types"));
addFileTypeItem(block, "aac", "", QVariant(), "",
".aac", "public.aac-audio", false);
addFileTypeItem(block, "ac3", "", QVariant(), "",
".ac3", "public.ac3-audio", false);
addFileTypeItem(block, "aiff", "", QVariant(), "",
".aiff", "public.aiff-audio", false);
addFileTypeItem(block, "mp1", "", QVariant(), "",
".mp1", "public.mp1", false);
addFileTypeItem(block, "mp2", "", QVariant(), "",
".mp2", "public.mp2", false);
addFileTypeItem(block, "mp3", "", QVariant(), "",
".mp3", "public.mp3", false);
addFileTypeItem(block, "mpc", "", QVariant(), "",
".mpc", "org.kreogist.musepack-format", false);
addFileTypeItem(block, "ofr", "", QVariant(), "",
".ofr", "org.kreogist.optimfrog-format", false);
addFileTypeItem(block, "opus", "", QVariant(), "",
".opus", "org.kreogist.opus-format", false);
addFileTypeItem(block, "spx", "", QVariant(), "",
".spx", "org.kreogist.speex-format", false);
panelData.append(block);
block=generateBlock(tr("Other File Types Association"));
addFileTypeItem(block, "m4a", "", QVariant(), "",
".m4a", "com.apple.m4a-audio", false);
addFileTypeItem(block, "mid", "", QVariant(), "",
".mid", "public.midi-audio", false);
addFileTypeItem(block, "midi", "", QVariant(), "",
".midi", "public.midi-audio", false);
addFileTypeItem(block, "ogg", "", QVariant(), "",
".ogg", "org.kreogist.ogg-format", false);
#ifdef Q_OS_WIN
addFileTypeItem(block, "wma", "", QVariant(), "",
".wma", "com.microsoft.windows-media-wma", false);
#endif
panelData.append(block);
break;
}
default:
break;
}
//Give back the panel data.
return panelData;
}
uint8_t RandomNumberGenerator::generateByte()
{
uint8_t result;
generateBlock(&result, 1);
return result;
}
void CBlockMgr::makeBlock()
{
srand(GetTickCount());
generateBlock((int *)block,NUM_OF_BLOCK_CREATION);
}
void dMap::shiftUp()
{
mDepth += 20;
for(int i=0; i<40; i++)
for(int j=0; j<30; j++)
{
delete mMap[i][j];
mMap[i][j] = mMap[i][j+15];
mMap[i][j+15] = NULL;
mVisible[i][j] = mVisible[i][j+15];
}
for(int i=0; i<40; i++)
for(int j=30; j<45; j++)
mVisible[i][j] = 0;
for(deque<dNPC*>::iterator i = mMonsters.begin(); i != mMonsters.end(); i++)
(*i)->getY() -= 15;
for(deque<dItem*>::iterator i = mItems.begin(); i != mItems.end(); i++)
{
(*i)->getY() -= 15;
if((*i)->getY() < 0)
{
delete (*i);
*i = NULL;
}
}
while(1)
{
deque<dItem*>::iterator i;
for(i = mItems.begin(); i != mItems.end(); i++)
{
if(!(*i))
{
mItems.erase(i);
break;
}
}
if(i == mItems.end())
break;
}
for(int i=0; i<2; i++)
for(int j=0; j<4; j++)
{
mOpenTop[i][j] = mOpenTop[i+1][j];
mOpenBottom[i][j] = mOpenBottom[i+1][j];
}
for(int j=0; j<4; j++)
mOpenTop[2][j] = mOpenBottom[2][j];
if(mDepth == DMAX_DEPTH)
mOpenBottom[2][0] = mOpenBottom[2][1] = mOpenBottom[2][2] = mOpenBottom[2][3] = false;
else do
{
for(int j=0; j<3; j++)
mOpenBottom[2][j] = random(0,1);
} while(!mOpenBottom[2][0] && !mOpenBottom[2][1] && !mOpenBottom[2][2] && !mOpenBottom[2][3]);
generateBlock(2);
}