/*
* This pops up a dialog box.
*/
int popupDialog (CDKSCREEN *screen, CDK_CSTRING2 mesg, int mesgCount, CDK_CSTRING2 buttons, int buttonCount)
{
/* Declare local variables. */
CDKDIALOG *popup = 0;
int choice;
/* Create the dialog box. */
popup = newCDKDialog (screen, CENTER, CENTER,
mesg, mesgCount,
buttons, buttonCount,
A_REVERSE, TRUE,
TRUE, FALSE);
/* Activate the dialog box */
drawCDKDialog (popup, TRUE);
/* Get the choice. */
choice = activateCDKDialog (popup, 0);
/* Destroy the dialog box. */
destroyCDKDialog (popup);
/* Clean the screen. */
eraseCDKScreen (screen);
refreshCDKScreen (screen);
/* Return the choice. */
return choice;
}
/*
* This pops up a message.
*/
void popupLabelAttrib (CDKSCREEN *screen, char **mesg, int count, chtype attrib)
{
CDKLABEL *popup = 0;
int oldCursState;
boolean functionKey;
/* Create the label. */
popup = newCDKLabel (screen, CENTER, CENTER, mesg, count, TRUE, FALSE);
setCDKLabelBackgroundAttrib(popup, attrib);
oldCursState = curs_set(0);
/* Draw it on the screen. */
drawCDKLabel (popup, TRUE);
/* Wait for some input. */
keypad (popup->win, TRUE);
getchCDKObject (ObjOf(popup), &functionKey);
/* Kill it. */
destroyCDKLabel (popup);
/* Clean the screen. */
curs_set(oldCursState);
eraseCDKScreen (screen);
refreshCDKScreen (screen);
}
int main(int argc, char **argv)
{
/* Declare variables. */
CDKSCREEN *cdkscreen;
CDKLABEL *demo;
WINDOW *cursesWin;
char *mesg[4];
CDK_PARAMS params;
CDKparseParams(argc, argv, ¶ms, CDK_MIN_PARAMS);
/* Set up CDK. */
cursesWin = initscr();
cdkscreen = initCDKScreen (cursesWin);
/* Start CDK Colors. */
initCDKColor();
/* Set the labels up. */
mesg[0] = "</5><#UL><#HL(30)><#UR>";
mesg[1] = "</5><#VL(10)>Hello World!<#VL(10)>";
mesg[2] = "</5><#LL><#HL(30)><#LR>";
/* Declare the labels. */
demo = newCDKLabel (cdkscreen,
CDKparamValue(¶ms, 'X', CENTER),
CDKparamValue(¶ms, 'Y', CENTER),
mesg, 3,
CDKparamValue(¶ms, 'N', TRUE),
CDKparamValue(¶ms, 'S', TRUE));
setCDKLabelBackgroundAttrib (demo, COLOR_PAIR(2));
/* Is the label null? */
if (demo == 0)
{
/* Clean up the memory. */
destroyCDKScreen (cdkscreen);
/* End curses... */
endCDK();
/* Spit out a message. */
printf ("Oops. Can't seem to create the label. Is the window too small?\n");
ExitProgram (EXIT_FAILURE);
}
/* Draw the CDK screen. */
refreshCDKScreen (cdkscreen);
waitCDKLabel (demo, ' ');
/* Clean up. */
destroyCDKLabel (demo);
destroyCDKScreen (cdkscreen);
endCDK();
ExitProgram (EXIT_SUCCESS);
}
/*
* This injects a single character into the widget.
*/
static int _injectCDKButton (CDKOBJS *object, chtype input)
{
CDKBUTTON *widget = (CDKBUTTON *)object;
int ret = unknownInt;
bool complete = FALSE;
setExitType (widget, 0);
/* Check a predefined binding. */
if (checkCDKObjectBind (vBUTTON, widget, input) != 0)
{
checkEarlyExit (widget);
complete = TRUE;
}
else
{
switch (input)
{
case KEY_ESC:
setExitType (widget, input);
complete = TRUE;
break;
case KEY_ERROR:
setExitType (widget, input);
complete = TRUE;
break;
case KEY_ENTER:
case SPACE:
if (widget->callback)
widget->callback (widget);
setExitType (widget, KEY_ENTER);
ret = 0;
complete = TRUE;
break;
case CDK_REFRESH:
eraseCDKScreen (ScreenOf (widget));
refreshCDKScreen (ScreenOf (widget));
break;
default:
BEEP ();
break;
}
}
if (!complete)
{
setExitType (widget, 0);
}
ResultOf (widget).valueInt = ret;
return (ret != unknownInt);
}
void displayError( CDKSCREEN* cdkscreen, const std::string & msg )
{
char* messgs[1] = { const_cast<char*>( msg.c_str() ) };
char* buttons[1] = { "Ok" };
CDKDIALOG *dlg = newCDKDialog( cdkscreen, CENTER, CENTER, messgs, 1, buttons, 1, A_REVERSE | A_BOLD, TRUE, TRUE, FALSE );
setCDKDialogBackgroundColor( dlg, "</2>" );
refreshCDKScreen( cdkscreen );
while( dlg->exitType != vESCAPE_HIT )
{
const int selection = activateCDKDialog( dlg, NULL );
switch( selection )
{
case 0:
{
dlg->exitType = vESCAPE_HIT;
break;
}
}
refreshCDKScreen( cdkscreen );
}
destroyCDKDialog( dlg );
}
//---------------------------------------------------------------------
//! @brief Set the text to display.
//! @param[in] _path The text.
//---------------------------------------------------------------------
void Button::setText( std::string const& _text )
{
text__ = _text;
if( button__ && _text.size() < width_str__.size() )
{
unsigned int spacer_length = ( width_str__.size() - _text.size() ) / 2;
std::string spacer;
for( unsigned int i = 1; i < spacer_length; ++i )
spacer += " ";
text_stored__ = "</5/B/U>|" + spacer + _text + spacer + "|";
setCDKButtonMessage( button__
, const_cast< char* >( text_stored__.c_str() ) );
refreshCDKScreen( cdk_screen__ );
}
if( label__ )
label__->setText( _text );
}
//---------------------------------------------------------------------
//! @brief Move the top-left corner of the Button to the
//! point designated by (_x, _y).
//! @param[in] _x X coordinate.
//! @param[in] _y Y coordinate.
//---------------------------------------------------------------------
void Button::move( float const& _x
, float const& _y )
{
x__ = _x;
y__ = _y;
if( button__ )
{
moveCDKButton( button__
, _x
, _y
, 0
, 1 );
refreshCDKScreen( cdk_screen__ );
}
if( label__ )
label__->move( _x
, _y );
}
boost::filesystem::path openFile( CDKSCREEN* cdkscreen, const std::string & title, const std::string & extensions )
{
CDKFSELECT *fileSelect = newCDKFselect( cdkscreen,
CENTER,
CENTER,
19,
64,
title.c_str(), "Music file:", A_NORMAL, '_', A_REVERSE,
"</5>", "</48>", "</N>", "</N>",
TRUE,
FALSE );
const char* filename = activateCDKFselect( fileSelect, NULL );
std::ostringstream os;
os << filename;
destroyCDKFselect( fileSelect );
refreshCDKScreen( cdkscreen );
return os.str();
}
void CButtonBar::Draw()
{
if (!m_pCurrentBarEntry) return;
if (!m_pCurrentBarEntry->szCurrentText.empty())
{
m_pCurrentBarEntry->Texts.push_back(MakeCString(m_pCurrentBarEntry->szCurrentText));
m_pCurrentBarEntry->szCurrentText.clear();
m_pCurrentBarEntry->iCurTextLength = 0;
}
if (m_pCurrentBarEntry->Texts.empty()) return;
if (m_pLabel) delete m_pLabel; // CDK has no propper way to change text...
m_pLabel = new CCDKLabel(CDKScreen, CENTER, BOTTOM, &m_pCurrentBarEntry->Texts[0], m_pCurrentBarEntry->Texts.size());
if (!m_pLabel)
throwerror(false, "Could not create button bar");
m_pLabel->SetBgColor(24);
m_pLabel->Draw();
refreshCDKScreen(CDKScreen);
}
SimpletuiTempMessage::SimpletuiTempMessage(Simpletui &tui, string text)
{
SplitString sText(text);
label=newCDKLabel(reinterpret_cast<CDKSCREEN*>(tui.cdk), CENTER, CENTER, sText.getPtr(), sText.getLength(), TRUE, FALSE);
refreshCDKScreen(reinterpret_cast<CDKSCREEN*>(tui.cdk));
}
/*
* This function injects a single character into the widget.
*/
float injectCDKFScale (CDKFSCALE *scale, chtype input)
{
/* Declare some local variables. */
int ppReturn = 1;
/* Set the exit type. */
scale->exitType = vEARLY_EXIT;
/* Draw the field. */
drawCDKFScaleField (scale);
/* Check if there is a pre-process function to be called. */
if (scale->preProcessFunction != 0)
{
/* Call the pre-process function. */
ppReturn = scale->preProcessFunction (vFSCALE, scale, scale->preProcessData, input);
}
/* Should we continue? */
if (ppReturn != 0)
{
/* Check for a key binding. */
if (checkCDKObjectBind(vFSCALE, scale, input) != 0)
{
scale->exitType = vESCAPE_HIT;
return 0.;
}
else
{
switch (input)
{
case KEY_LEFT : case 'd' : case '-' : case KEY_DOWN :
if (scale->current > scale->low)
{
scale->current -= scale->inc;
if (scale->current < scale->low)
{
scale->current = scale->low;
}
}
else
{
Beep();
}
break;
case KEY_RIGHT : case 'u' : case '+' : case KEY_UP :
if (scale->current < scale->high)
{
scale->current += scale->inc;
if (scale->current > scale->high)
{
scale->current = scale->high;
}
}
else
{
Beep();
}
break;
case KEY_PPAGE : case 'U' : case CONTROL('B') :
if ((scale->current + scale->fastinc) <= scale->high)
{
scale->current += scale->fastinc;
}
else
{
Beep();
}
break;
case KEY_NPAGE : case 'D' : case CONTROL('F') :
if ((scale->current - scale->fastinc) >= scale->low)
{
scale->current -= scale->fastinc;
}
else
{
Beep();
}
break;
case KEY_HOME : case 'g' : case '0' :
scale->current = scale->low;
break;
case KEY_END : case 'G' : case '$' :
scale->current = scale->high;
break;
case KEY_RETURN : case TAB : case KEY_ENTER :
scale->exitType = vNORMAL;
return (scale->current);
case KEY_ESC :
scale->exitType = vESCAPE_HIT;
return (scale->current);
case CDK_REFRESH :
eraseCDKScreen (ScreenOf(scale));
refreshCDKScreen (ScreenOf(scale));
break;
default :
break;
}
}
/* Should we call a post-process? */
if (scale->postProcessFunction != 0)
{
scale->postProcessFunction (vFSCALE, scale, scale->postProcessData, input);
}
}
/* Draw the field window. */
drawCDKFScaleField (scale);
/* Set the exit type and return. */
scale->exitType = vEARLY_EXIT;
return 0.;
}
bool InstallFiles()
{
ButtonBar.Clear();
ButtonBar.AddButton("C", "Cancel");
ButtonBar.Draw();
char *msg;
char *dbuttons[2] = { GetTranslation("Continue"), GetTranslation("Exit program") };
if ((InstallInfo.dest_dir_type == DEST_SELECT) || (InstallInfo.dest_dir_type == DEST_DEFAULT))
{
msg = CreateText(GetTranslation("This will install %s to the following directory:\n%s\nContinue?"),
InstallInfo.program_name.c_str(), MakeCString(InstallInfo.dest_dir));
}
else
{
msg = CreateText(GetTranslation("This will install %s\nContinue?"), InstallInfo.program_name.c_str());
}
CCDKDialog Diag(CDKScreen, CENTER, CENTER, msg, dbuttons, 2);
Diag.SetBgColor(26);
int sel = Diag.Activate();
Diag.Destroy();
refreshCDKScreen(CDKScreen);
if (sel == 1)
return false;
CCDKSWindow InstallOutput(CDKScreen, 0, 6, GetDefaultHeight()-5, -1,
CreateText("<C></29/B>%s", GetTranslation("Install output")), 2000);
InstallOutput.SetBgColor(5);
nodelay(WindowOf(InstallOutput.GetSWin()), true); // Make sure input doesn't block
const int maxx = getmaxx(InstallOutput.GetSWin()->win);
CCDKSWindow ProggWindow(CDKScreen, 0, 2, 5, maxx, NULL, 4);
ProggWindow.SetBgColor(5);
ProggWindow.AddText("");
ProggWindow.AddText(CreateText("</B/29>%s:<!29!B>", GetTranslation("Status")));
ProggWindow.AddText(CreateText("%s (1/%d)", GetTranslation("Extracting files"), InstallInfo.command_entries.size()+1),
true, BOTTOM, 24);
CCDKHistogram ProgressBar(CDKScreen, 25, 3, 1, maxx-29, HORIZONTAL,
CreateText("<C></29/B>%s", GetTranslation("Progress")), false);
ProgressBar.SetBgColor(5);
ProgressBar.SetHistogram(vPERCENT, TOP, 0, 100, 0, COLOR_PAIR (24) | A_REVERSE | ' ', A_BOLD);
setCDKSwindowLLChar(ProggWindow.GetSWin(), ACS_LTEE);
setCDKSwindowLRChar(ProggWindow.GetSWin(), ACS_RTEE);
InstallOutput.Draw();
ProggWindow.Draw();
// Check if we need root access
char *passwd = NULL;
LIBSU::CLibSU SuHandler;
SuHandler.SetUser("root");
SuHandler.SetTerminalOutput(false);
bool askpass = false;
for (std::list<command_entry_s *>::iterator it=InstallInfo.command_entries.begin();
it!=InstallInfo.command_entries.end(); it++)
{
if ((*it)->need_root != NO_ROOT)
{
// Command may need root permission, check if it is so
if ((*it)->need_root == DEPENDED_ROOT)
{
param_entry_s *p = GetParamByVar((*it)->dep_param);
if (p && !WriteAccess(p->value))
{
(*it)->need_root = NEED_ROOT;
if (!askpass) askpass = true;
}
}
else if (!askpass) askpass = true;
}
}
if (!askpass)
askpass = !WriteAccess(InstallInfo.dest_dir);
// Ask root password if one of the command entries need root access and root isn't passwordless
if (askpass && SuHandler.NeedPassword())
{
CCDKEntry entry(CDKScreen, CENTER, CENTER,
GetTranslation("This installation requires root(administrator) privileges in order to continue\n"
"Please enter the password of the root user"), "", 60, 0, 256, vHMIXED);
entry.SetHiddenChar('*');
entry.SetBgColor(26);
while(1)
{
char *sz = entry.Activate();
if ((entry.ExitType() != vNORMAL) || !sz || !sz[0])
{
if (YesNoBox(GetTranslation("Root access is required to continue\nAbort installation?")))
EndProg();
refreshCDKScreen(CDKScreen);
}
else
{
if (SuHandler.TestSU(sz))
{
passwd = strdup(sz);
for (short s=0;s<strlen(sz);s++) sz[s] = 0;
break;
}
for (short s=0;s<strlen(sz);s++) sz[s] = 0;
entry.Clean();
// Some error appeared
if (SuHandler.GetError() == LIBSU::CLibSU::SU_ERROR_INCORRECTPASS)
{
WarningBox(GetTranslation("Incorrect password given for root user\nPlease retype"));
}
else
{
throwerror(true, GetTranslation("Could not use su to gain root access\n"
"Make sure you can use su(adding the current user to the wheel group may help)"));
}
}
}
// Restore screen
entry.Destroy();
refreshCDKScreen(CDKScreen);
}
short percent = 0;
bool alwaysroot = false;
if (!WriteAccess(InstallInfo.dest_dir))
{
CExtractAsRootFunctor Extracter;
Extracter.SetUpdateProgFunc(SUUpdateProgress, &ProgressBar);
Extracter.SetUpdateTextFunc(SUUpdateText, &InstallOutput);
if (!Extracter(passwd))
{
CleanPasswdString(passwd);
passwd = NULL;
throwerror(true, "Error during extracting files");
}
InstallOutput.AddText("Done!\n");
alwaysroot = true; // Install commands need root now too
}
else
{
while(percent<100)
{
std::string curfile;
percent = ExtractArchive(curfile);
InstallOutput.AddText("Extracting file: " + curfile, false);
if (percent==100) InstallOutput.AddText("Done!", false);
else if (percent==-1) throwerror(true, "Error during extracting files");
ProgressBar.SetValue(0, 100, percent/(1+InstallInfo.command_entries.size()));
ProgressBar.Draw();
chtype input = getch();
if (input == 'c')
{
if (YesNoBox(GetTranslation("Install commands are still running\n"
"If you abort now this may lead to a broken installation\n"
"Are you sure?")))
{
CleanPasswdString(passwd);
passwd = NULL;
EndProg();
}
}
}
}
SuHandler.SetThinkFunc(InstThinkFunc, passwd);
SuHandler.SetOutputFunc(PrintInstOutput, &InstallOutput);
percent = 100/(1+InstallInfo.command_entries.size()); // Convert to overall progress
short step = 2; // Not 1, because extracting files is also a step
for (std::list<command_entry_s*>::iterator it=InstallInfo.command_entries.begin();
it!=InstallInfo.command_entries.end(); it++, step++)
{
if ((*it)->command.empty()) continue;
ProggWindow.Clear();
ProggWindow.AddText("");
ProggWindow.AddText(CreateText("</B/29>%s:<!29!B>", GetTranslation("Status")));
ProggWindow.AddText(CreateText("%s (%d/%d)", GetTranslation((*it)->description.c_str()), step,
InstallInfo.command_entries.size()+1), true, BOTTOM, 24);
ProgressBar.Draw();
std::string command = (*it)->command + " " + GetParameters(*it);
InstallOutput.AddText("");
InstallOutput.AddText(CreateText("Execute: %s", command.c_str()));
InstallOutput.AddText("");
InstallOutput.AddText("");
if (((*it)->need_root == NEED_ROOT) || alwaysroot)
{
SuHandler.SetPath((*it)->path.c_str());
SuHandler.SetCommand(command);
if (!SuHandler.ExecuteCommand(passwd))
{
if ((*it)->exit_on_failure)
{
CleanPasswdString(passwd);
passwd = NULL;
throwerror(true, "%s\n('%s')", GetTranslation("Failed to execute install command"),
SuHandler.GetErrorMsgC());
}
}
}
else
{
// Redirect stderr to stdout, so that errors will be displayed too
command += " 2>&1";
setenv("PATH", (*it)->path.c_str(), 1);
FILE *pipe = popen(command.c_str(), "r");
char term[1024];
if (pipe)
{
while (fgets(term, sizeof(term), pipe))
{
InstallOutput.AddText(term);
chtype input = getch();
if (input == 'c') /*injectCDKSwindow(InstallOutput.GetSWin(), input);*/
{
if (YesNoBox(GetTranslation("Install commands are still running\n"
"If you abort now this may lead to a broken installation\n"
"Are you sure?")))
{
CleanPasswdString(passwd);
passwd = NULL;
EndProg();
}
}
}
// Check if command exitted normally and close pipe
int state = pclose(pipe);
if (!WIFEXITED(state) || (WEXITSTATUS(state) == 127)) // SH returns 127 if command execution failes
{
if ((*it)->exit_on_failure)
{
CleanPasswdString(passwd);
passwd = NULL;
throwerror(true, "Failed to execute install command");
}
}
}
else
{
CleanPasswdString(passwd);
passwd = NULL;
throwerror(true, "Could not execute installation commands (could not open pipe)");
}
#if 0
// Need to find a good way to safely suspend a process...this code doesn't always work :(
int pipefd[2];
pipe(pipefd);
pid_t pid = fork();
if (pid == -1) throwerror(true, "Error during command execution: Could not fork process");
else if (pid) // Parent process
{
close(pipefd[1]); // We're not going to write here
std::string out;
char c;
int compid = -1; // PID of the executed command
while(read(pipefd[0], &c, sizeof(c)) > 0)
{
out += c;
if (c == '\n')
{
if (compid == -1)
{
compid = atoi(out.c_str());
InstallOutput.AddText(CreateText("pid: %d compid: %d", pid, compid), false);
}
else InstallOutput.AddText(out, false);
out.clear();
}
chtype input = getch();
if (input != ERR) /*injectCDKSwindow(InstallOutput.GetSWin(), input);*/
{
if (kill(compid, SIGTSTP) < 0) // Pause command execution
WarningBox("PID Error: %s\n", strerror(errno));
char *buttons[2] = { GetTranslation("Yes"), GetTranslation("No") };
CCharListHelper msg;
msg.AddItem(GetTranslation("This will abort the installation"));
msg.AddItem(GetTranslation("Are you sure?"));
CCDKDialog dialog(CDKScreen, CENTER, CENTER, msg, msg.Count(), buttons, 2);
dialog.SetBgColor(26);
int ret = dialog.Activate();
bool cont = ((ret == 1) || (dialog.ExitType() != vNORMAL));
dialog.Destroy();
refreshCDKScreen(CDKScreen);
if (!cont)
{
kill(pid, SIGTERM);
EndProg();
}
kill(compid, SIGCONT); // Continue command execution
}
}
close (pipefd[0]);
int status;
//waitpid(pid, &status, 0);
}
else // Child process
{
// Redirect stdout to pipe
close(STDOUT_FILENO);
dup (pipefd[1]);
close (pipefd[0]); // No need to read here
// Make sure no errors are printed and write pid of new command
command += " 2> /dev/null & echo $!";
execl("/bin/sh", "sh", "-c", command.c_str(), NULL);
system(CreateText("echo %s", strerror(errno)));
_exit(1);
}
#endif
}
percent += (1.0f/((float)InstallInfo.command_entries.size()+1.0f))*100.0f;
ProgressBar.SetValue(0, 100, percent);
}
ProgressBar.SetValue(0, 100, 100);
ProgressBar.Draw();
CleanPasswdString(passwd);
passwd = NULL;
ButtonBar.Clear();
ButtonBar.AddButton("Arrows", "Scroll install output");
ButtonBar.AddButton("Enter", (FileExists(InstallInfo.own_dir + "/config/finish")) ? "Continue" : "Finish"); // HACK
ButtonBar.Draw();
WarningBox("Installation of %s complete!", InstallInfo.program_name.c_str());
InstallOutput.Activate();
return (InstallOutput.ExitType() == vNORMAL);
}
int RenderCurses::render(Pagination* pagination, unsigned int pageNum, bool doBlit)
{
clc::Log::info("ocher.render.ncurses", "render page %u %u", pageNum, doBlit);
m_x = 0;
m_y = 0;
if (m_height) {
wclear(m_scr);
}
unsigned int layoutOffset;
unsigned int strOffset;
if (!pageNum) {
layoutOffset = 0;
strOffset = 0;
} else if (! pagination->get(pageNum-1, &layoutOffset, &strOffset)) {
// Previous page not already paginated?
// Perhaps at end of book?
clc::Log::error("ocher.renderer.ncurses", "page %u not found", pageNum);
return -1;
}
const unsigned int N = m_layout.size();
const char *raw = m_layout.data();
ASSERT(layoutOffset < N);
for (unsigned int i = layoutOffset; i < N; ) {
ASSERT(i+2 <= N);
uint16_t code = *(uint16_t*)(raw+i);
i += 2;
unsigned int opType = (code>>12)&0xf;
unsigned int op = (code>>8)&0xf;
unsigned int arg = code & 0xff;
switch (opType) {
case Layout::OpPushTextAttr:
clc::Log::debug("ocher.render.ncurses", "OpPushTextAttr");
switch (op) {
case Layout::AttrBold:
pushAttrs();
a[ai].b = 1;
if (doBlit)
applyAttrs(1);
break;
case Layout::AttrUnderline:
pushAttrs();
a[ai].ul = 1;
if (doBlit)
applyAttrs(1);
break;
case Layout::AttrItalics:
pushAttrs();
a[ai].em = 1;
if (doBlit)
applyAttrs(1);
break;
case Layout::AttrSizeRel:
pushAttrs();
break;
case Layout::AttrSizeAbs:
pushAttrs();
break;
default:
clc::Log::error("ocher.render.ncurses", "unknown OpPushTextAttr");
ASSERT(0);
break;
}
break;
case Layout::OpPushLineAttr:
clc::Log::debug("ocher.render.ncurses", "OpPushLineAttr");
switch (op) {
case Layout::LineJustifyLeft:
break;
case Layout::LineJustifyCenter:
break;
case Layout::LineJustifyFull:
break;
case Layout::LineJustifyRight:
break;
default:
clc::Log::error("ocher.render.ncurses", "unknown OpPushLineAttr");
ASSERT(0);
break;
}
break;
case Layout::OpCmd:
switch (op) {
case Layout::CmdPopAttr:
clc::Log::trace("ocher.render.ncurses", "OpCmd CmdPopAttr");
if (arg == 0)
arg = 1;
while (arg--)
popAttrs();
break;
case Layout::CmdOutputStr: {
clc::Log::trace("ocher.render.ncurses", "OpCmd CmdOutputStr");
ASSERT(i + sizeof(clc::Buffer*) <= N);
clc::Buffer *str = *(clc::Buffer**)(raw+i);
ASSERT(strOffset <= str->size());
int breakOffset = outputWrapped(str, strOffset, doBlit);
strOffset = 0;
if (breakOffset >= 0) {
pagination->set(pageNum, i-2, breakOffset);
if (doBlit) {
refreshCDKScreen(m_screen);
}
clc::Log::debug("ocher.renderer.ncurses", "page %u break", pageNum);
return 0;
}
i += sizeof(clc::Buffer*);
break;
}
case Layout::CmdForcePage:
clc::Log::trace("ocher.render.ncurses", "OpCmd CmdForcePage");
break;
default:
clc::Log::error("ocher.render.ncurses", "unknown OpCmd");
ASSERT(0);
break;
}
break;
case Layout::OpSpacing:
break;
case Layout::OpImage:
break;
default:
clc::Log::error("ocher.render.ncurses", "unknown op type");
ASSERT(0);
break;
};
}
clc::Log::debug("ocher.renderer.ncurses", "page %u done", pageNum);
refreshCDKScreen(m_screen);
return 1;
}
/*
* This function injects a single character into the widget.
*/
static int _injectCDKUScale (CDKOBJS *object, chtype input)
{
CDKUSCALE *widget = (CDKUSCALE *)object;
int ppReturn = 1;
unsigned ret = unknownUnsigned;
bool complete = FALSE;
/* Set the exit type. */
setExitType(widget, 0);
/* Draw the field. */
drawCDKUScaleField (widget);
/* Check if there is a pre-process function to be called. */
if (PreProcessFuncOf(widget) != 0)
{
/* Call the pre-process function. */
ppReturn = PreProcessFuncOf(widget) (vUSCALE, widget, PreProcessDataOf(widget), input);
}
/* Should we continue? */
if (ppReturn != 0)
{
/* Check for a key binding. */
if (checkCDKObjectBind(vUSCALE, widget, input) != 0)
{
checkEarlyExit(widget);
complete = TRUE;
}
else
{
switch (input)
{
case KEY_LEFT :
setEditPosition(widget, widget->fieldEdit + 1);
break;
case KEY_RIGHT :
setEditPosition(widget, widget->fieldEdit - 1);
break;
case KEY_DOWN :
Decrement(widget->current, widget->inc);
break;
case KEY_UP :
Increment(widget->current, widget->inc);
break;
case KEY_PPAGE :
Increment(widget->current, widget->fastinc);
break;
case KEY_NPAGE :
Decrement(widget->current, widget->fastinc);
break;
case KEY_HOME :
widget->current = widget->low;
break;
case KEY_END :
widget->current = widget->high;
break;
case KEY_TAB :
case KEY_ENTER :
setExitType(widget, input);
ret = (widget->current);
complete = TRUE;
break;
case KEY_ESC :
setExitType(widget, input);
complete = TRUE;
break;
case CDK_REFRESH :
eraseCDKScreen (ScreenOf(widget));
refreshCDKScreen (ScreenOf(widget));
break;
default :
if (widget->fieldEdit)
{
if (!performEdit(widget, input))
BEEP();
}
else
{
/*
* The cursor is not within the editable text. Interpret
* input as commands.
*/
switch (input)
{
case 'd':
case '-':
return _injectCDKUScale(object, KEY_DOWN);
case '+':
return _injectCDKUScale(object, KEY_UP);
case 'D':
return _injectCDKUScale(object, KEY_NPAGE);
case '0':
return _injectCDKUScale(object, KEY_HOME);
default:
BEEP();
break;
}
}
break;
}
}
limitCurrentValue(widget);
/* Should we call a post-process? */
if (!complete && (PostProcessFuncOf(widget) != 0))
{
PostProcessFuncOf(widget) (vUSCALE, widget, PostProcessDataOf(widget), input);
}
}
if (!complete) {
drawCDKUScaleField (widget);
setExitType(widget, 0);
}
ResultOf(widget).valueUnsigned = ret;
return (ret != unknownUnsigned);
}
bool CFileDialog::Activate()
{
char *buttons[] = { GetTranslation("Open directory"), GetTranslation("Select directory"), GetTranslation("Cancel") };
char label[] = "Dir: ";
char curdir[1024];
ButtonBar.Push();
ButtonBar.AddButton("TAB", "Next button");
ButtonBar.AddButton("ENTER", "Activate button");
ButtonBar.AddButton("Arrows", "Navigate menu");
ButtonBar.AddButton("C", "Create directory");
ButtonBar.AddButton("A", "About");
ButtonBar.AddButton("ESC", "Cancel");
ButtonBar.Draw();
if (!getcwd(curdir, sizeof(curdir))) throwerror(true, "Could not read current directory");
if (chdir(m_szStartDir.c_str()) != 0)
throwerror(true, "Could not open directory '%s'", m_szStartDir.c_str());
if (!ReadDir(m_szStartDir)) throwerror(true, "Could not read directory '%s'", m_szStartDir.c_str());
CCDKButtonBox ButtonBox(CDKScreen, CENTER, GetDefaultHeight(), 1, GetDefaultWidth(), 0, 1, 3, buttons, 3);
ButtonBox.SetBgColor(5);
if (!m_pCurDirWin && !m_pFileList)
{
m_pCurDirWin = new CCDKSWindow(CDKScreen, CENTER, getbegy(ButtonBox.GetBBox()->win)-2, 2, GetDefaultWidth()+1,
NULL, 1);
m_pCurDirWin->SetBgColor(5);
if (!m_pFileList)
{
m_pFileList = new CCDKAlphaList(CDKScreen, CENTER, 2, getbegy(m_pCurDirWin->GetSWin()->win)-1, GetDefaultWidth()+1,
const_cast<char*>(m_szTitle.c_str()), label, &m_DirItems[0], m_DirItems.size());
m_pFileList->SetBgColor(5);
setCDKEntryPreProcess(m_pFileList->GetAList()->entryField, CreateDirCB, this);
//m_pFileList->GetAList()->entryField->dispType = vVIEWONLY; // HACK: Disable backspace
}
setCDKAlphalistLLChar(m_pFileList->GetAList(), ACS_LTEE);
setCDKAlphalistLRChar(m_pFileList->GetAList(), ACS_RTEE);
setCDKLabelLLChar(m_pCurDirWin->GetSWin(), ACS_LTEE);
setCDKLabelLRChar(m_pCurDirWin->GetSWin(), ACS_RTEE);
setCDKButtonboxULChar(ButtonBox.GetBBox(), ACS_LTEE);
setCDKButtonboxURChar(ButtonBox.GetBBox(), ACS_RTEE);
}
m_pFileList->Draw();
m_pCurDirWin->Draw();
ButtonBox.Draw();
m_pFileList->Bind(KEY_TAB, SwitchButtonK, ButtonBox.GetBBox()); // Pas TAB through ButtonBox
m_szDestDir = m_szStartDir;
UpdateCurDirText();
while(true)
{
// HACK: Give textbox content
setCDKEntryValue(m_pFileList->GetAList()->entryField,
chtype2Char(m_pFileList->GetAList()->scrollField->item[m_pFileList->GetAList()->scrollField->currentItem]));
char *selection = m_pFileList->Activate();
if ((m_pFileList->ExitType() != vNORMAL) || (ButtonBox.GetCurrent() == 2)) break;
if (!selection || !selection[0]) continue;
if (ButtonBox.GetCurrent() == 1)
{
if (m_bAskWAccess && !WriteAccess(m_szDestDir))
{
char *dbuttons[2] = { GetTranslation("Continue as root"), GetTranslation("Choose another directory") };
CCDKDialog Diag(CDKScreen, CENTER, CENTER,
GetTranslation("You don't have write permissions for this directory.\n"
"The files can be extracted as the root user,\n"
"but you'll need to enter the root password for this later."), dbuttons, 2);
Diag.SetBgColor(26);
int sel = Diag.Activate();
Diag.Destroy();
refreshCDKScreen(CDKScreen);
if (sel)
continue;
}
break;
}
if (!FileExists(selection))
{
if (YesNoBox(GetTranslation("Directory does not exist\nDo you want to create it?")))
{
if (mkdir(selection, (S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH)) != 0)
{
WarningBox("%s\n%.75s\n%.75s", GetTranslation("Could not create directory"), selection,
strerror(errno));
continue;
}
}
else
continue;
}
UpdateFileList(selection);
}
bool success = ((m_pFileList->ExitType() != vESCAPE_HIT) && (ButtonBox.GetCurrent() == 1));
ButtonBar.Pop();
if (m_bRestoreDir)
chdir(curdir); // Return back to original directory
return success;
}
/*
* This allows the user to use the cursor keys to adjust the
* position of the widget.
*/
void positionCDKObject (CDKOBJS *obj, WINDOW *win)
{
/* *INDENT-EQLS* */
CDKSCREEN *screen = ScreenOf (obj);
WINDOW *parent = screen->window;
int origX = getbegx (win);
int origY = getbegy (win);
int begX = getbegx (parent);
int begY = getbegy (parent);
int endX = begX + getmaxx (WindowOf (obj));
int endY = begY + getmaxy (WindowOf (obj));
chtype key;
boolean functionKey;
/* Let them move the widget around until they hit return. */
while ((key = (chtype)getchCDKObject (obj, &functionKey)) != KEY_ENTER)
{
switch (key)
{
case KEY_UP:
case '8':
if (getbegy (win) > begY)
{
moveCDKObject (obj, 0, -1, TRUE, TRUE);
}
else
{
BEEP ();
}
break;
case KEY_DOWN:
case '2':
if (getendy (win) < endY)
{
moveCDKObject (obj, 0, 1, TRUE, TRUE);
}
else
{
BEEP ();
}
break;
case KEY_LEFT:
case '4':
if (getbegx (win) > begX)
{
moveCDKObject (obj, -1, 0, TRUE, TRUE);
}
else
{
BEEP ();
}
break;
case KEY_RIGHT:
case '6':
if (getendx (win) < endX)
{
moveCDKObject (obj, 1, 0, TRUE, TRUE);
}
else
{
BEEP ();
}
break;
case '7':
if (getbegy (win) > begY && getbegx (win) > begX)
{
moveCDKObject (obj, -1, -1, TRUE, TRUE);
}
else
{
BEEP ();
}
break;
case '9':
if (getendx (win) < endX && getbegy (win) > begY)
{
moveCDKObject (obj, 1, -1, TRUE, TRUE);
}
else
{
BEEP ();
}
break;
case '1':
if (getbegx (win) > begX && getendy (win) < endY)
{
moveCDKObject (obj, -1, 1, TRUE, TRUE);
}
else
{
BEEP ();
}
break;
case '3':
if (getendx (win) < endX && getendy (win) < endY)
{
moveCDKObject (obj, 1, 1, TRUE, TRUE);
}
else
{
BEEP ();
}
break;
case '5':
moveCDKObject (obj, CENTER, CENTER, FALSE, TRUE);
break;
case 't':
moveCDKObject (obj, getbegx (win), TOP, FALSE, TRUE);
break;
case 'b':
moveCDKObject (obj, getbegx (win), BOTTOM, FALSE, TRUE);
break;
case 'l':
moveCDKObject (obj, LEFT, getbegy (win), FALSE, TRUE);
break;
case 'r':
moveCDKObject (obj, RIGHT, getbegy (win), FALSE, TRUE);
break;
case 'c':
moveCDKObject (obj, CENTER, getbegy (win), FALSE, TRUE);
break;
case 'C':
moveCDKObject (obj, getbegx (win), CENTER, FALSE, TRUE);
break;
case CDK_REFRESH:
eraseCDKScreen (ScreenOf (obj));
refreshCDKScreen (ScreenOf (obj));
break;
case KEY_ESC:
moveCDKObject (obj, origX, origY, FALSE, TRUE);
break;
default:
BEEP ();
break;
}
}
}
int main(int argc, char **argv)
{
/* Declare vars. */
CDKSCREEN *cdkscreen = 0;
CDKHISTOGRAM *volume = 0;
CDKHISTOGRAM *bass = 0;
CDKHISTOGRAM *treble = 0;
WINDOW *cursesWin = 0;
char *volumeTitle = "<C></5>Volume<!5>";
char *bassTitle = "<C></5>Bass <!5>";
char *trebleTitle = "<C></5>Treble<!5>";
CDK_PARAMS params;
boolean Box;
CDKparseParams(argc, argv, ¶ms, CDK_CLI_PARAMS);
Box = CDKparamValue(¶ms, 'N', TRUE);
/* Set up CDK. */
cursesWin = initscr();
cdkscreen = initCDKScreen (cursesWin);
/* Start CDK Color. */
initCDKColor();
/* Create the histogram objects. */
volume = newCDKHistogram (cdkscreen,
CDKparamValue(¶ms, 'X', 10),
CDKparamValue(¶ms, 'Y', 10),
CDKparamValue(¶ms, 'H', 1),
CDKparamValue(¶ms, 'W', -2),
HORIZONTAL, volumeTitle,
Box,
CDKparamValue(¶ms, 'S', FALSE));
if (volume == 0)
{
/* Exit CDK. */
destroyCDKScreen (cdkscreen);
endCDK();
/* Print out a message and exit. */
printf ("Oops. Can not make volume histogram. Is the window big enough??\n");
ExitProgram (EXIT_FAILURE);
}
bass = newCDKHistogram (cdkscreen,
CDKparamValue(¶ms, 'X', 10),
CDKparamValue(¶ms, 'Y', 14),
CDKparamValue(¶ms, 'H', 1),
CDKparamValue(¶ms, 'W', -2),
HORIZONTAL, bassTitle,
Box,
CDKparamValue(¶ms, 'S', FALSE));
if (bass == 0)
{
/* Exit CDK. */
destroyCDKHistogram (volume);
destroyCDKScreen (cdkscreen);
endCDK();
/* Print out a message and exit. */
printf ("Oops. Can not make bass histogram. Is the window big enough??\n");
ExitProgram (EXIT_FAILURE);
}
treble = newCDKHistogram (cdkscreen,
CDKparamValue(¶ms, 'X', 10),
CDKparamValue(¶ms, 'Y', 18),
CDKparamValue(¶ms, 'H', 1),
CDKparamValue(¶ms, 'W', -2),
HORIZONTAL, trebleTitle,
Box,
CDKparamValue(¶ms, 'S', FALSE));
if (treble == 0)
{
/* Exit CDK. */
destroyCDKHistogram (volume);
destroyCDKHistogram (bass);
destroyCDKScreen (cdkscreen);
endCDK();
/* Print out a message and exit. */
printf ("Oops. Can not make treble histogram. Is the window big enough??\n");
ExitProgram (EXIT_FAILURE);
}
#define BAR(a,b,c) A_BOLD, a, b, c, ' '|A_REVERSE|COLOR_PAIR(3), Box
/* Set the histogram values. */
setCDKHistogram (volume, vPERCENT, CENTER, BAR(0, 10, 6));
setCDKHistogram (bass , vPERCENT, CENTER, BAR(0, 10, 3));
setCDKHistogram (treble, vPERCENT, CENTER, BAR(0, 10, 7));
refreshCDKScreen (cdkscreen);
sleep (4);
/* Set the histogram values. */
setCDKHistogram (volume, vPERCENT, CENTER, BAR(0, 10, 8));
setCDKHistogram (bass , vPERCENT, CENTER, BAR(0, 10, 1));
setCDKHistogram (treble, vPERCENT, CENTER, BAR(0, 10, 9));
refreshCDKScreen (cdkscreen);
sleep (4);
/* Set the histogram values. */
setCDKHistogram (volume, vPERCENT, CENTER, BAR(0, 10, 10));
setCDKHistogram (bass , vPERCENT, CENTER, BAR(0, 10, 7));
setCDKHistogram (treble, vPERCENT, CENTER, BAR(0, 10, 10));
refreshCDKScreen (cdkscreen);
sleep (4);
/* Set the histogram values. */
setCDKHistogram (volume, vPERCENT, CENTER, BAR(0, 10, 1));
setCDKHistogram (bass , vPERCENT, CENTER, BAR(0, 10, 8));
setCDKHistogram (treble, vPERCENT, CENTER, BAR(0, 10, 3));
refreshCDKScreen (cdkscreen);
sleep (4);
/* Set the histogram values. */
setCDKHistogram (volume, vPERCENT, CENTER, BAR(0, 10, 3));
setCDKHistogram (bass , vPERCENT, CENTER, BAR(0, 10, 3));
setCDKHistogram (treble, vPERCENT, CENTER, BAR(0, 10, 3));
refreshCDKScreen (cdkscreen);
sleep (4);
/* Set the histogram values. */
setCDKHistogram (volume, vPERCENT, CENTER, BAR(0, 10, 10));
setCDKHistogram (bass , vPERCENT, CENTER, BAR(0, 10, 10));
setCDKHistogram (treble, vPERCENT, CENTER, BAR(0, 10, 10));
refreshCDKScreen (cdkscreen);
sleep (4);
/* Clean up. */
destroyCDKHistogram (volume);
destroyCDKHistogram (bass);
destroyCDKHistogram (treble);
destroyCDKScreen (cdkscreen);
endCDK();
ExitProgram (EXIT_SUCCESS);
}
/*
* Run the Add Target to Group dialog
*/
void addTgtToGrpDialog(CDKSCREEN *main_cdk_screen) {
WINDOW *add_tgt_window = 0;
CDKSCREEN *add_tgt_screen = 0;
CDKLABEL *add_tgt_info = 0;
CDKENTRY *tgt_name = 0;
CDKSCALE *rel_tgt_id = 0;
CDKBUTTON *ok_button = 0, *cancel_button = 0;
tButtonCallback ok_cb = &okButtonCB, cancel_cb = &cancelButtonCB;
char dev_grp_name[MAX_SYSFS_ATTR_SIZE] = {0},
tgt_grp_name[MAX_SYSFS_ATTR_SIZE] = {0},
attr_path[MAX_SYSFS_PATH_SIZE] = {0},
attr_value[MAX_SYSFS_ATTR_SIZE] = {0};
char *error_msg = NULL;
char *add_tgt_info_msg[TGT_GRP_INFO_LINES] = {NULL};
int add_tgt_window_lines = 0, add_tgt_window_cols = 0, window_y = 0,
window_x = 0, temp_int = 0, i = 0, traverse_ret = 0;
/* Have the user choose a SCST device group */
getSCSTDevGrpChoice(main_cdk_screen, dev_grp_name);
if (dev_grp_name[0] == '\0')
return;
/* Get target group choice from user (based on previously
* selected device group) */
getSCSTTgtGrpChoice(main_cdk_screen, dev_grp_name, tgt_grp_name);
if (tgt_grp_name[0] == '\0')
return;
/* New CDK screen */
add_tgt_window_lines = 11;
add_tgt_window_cols = 55;
window_y = ((LINES / 2) - (add_tgt_window_lines / 2));
window_x = ((COLS / 2) - (add_tgt_window_cols / 2));
add_tgt_window = newwin(add_tgt_window_lines, add_tgt_window_cols,
window_y, window_x);
if (add_tgt_window == NULL) {
errorDialog(main_cdk_screen, NEWWIN_ERR_MSG, NULL);
return;
}
add_tgt_screen = initCDKScreen(add_tgt_window);
if (add_tgt_screen == NULL) {
errorDialog(main_cdk_screen, CDK_SCR_ERR_MSG, NULL);
return;
}
boxWindow(add_tgt_window, COLOR_DIALOG_BOX);
wbkgd(add_tgt_window, COLOR_DIALOG_TEXT);
wrefresh(add_tgt_window);
while (1) {
/* Information label */
SAFE_ASPRINTF(&add_tgt_info_msg[0],
"</31/B>Adding SCST target to target group...");
SAFE_ASPRINTF(&add_tgt_info_msg[1], " ");
SAFE_ASPRINTF(&add_tgt_info_msg[2],
"</B>Device group:<!B>\t%s", dev_grp_name);
SAFE_ASPRINTF(&add_tgt_info_msg[3],
"</B>Target group:<!B>\t%s", tgt_grp_name);
add_tgt_info = newCDKLabel(add_tgt_screen, (window_x + 1),
(window_y + 1), add_tgt_info_msg, ADD_TGT_INFO_LINES,
FALSE, FALSE);
if (!add_tgt_info) {
errorDialog(main_cdk_screen, LABEL_ERR_MSG, NULL);
break;
}
setCDKLabelBackgroundAttrib(add_tgt_info, COLOR_DIALOG_TEXT);
/* Target name (entry) */
tgt_name = newCDKEntry(add_tgt_screen, (window_x + 1), (window_y + 6),
NULL, "</B>Target Name: ",
COLOR_DIALOG_SELECT, '_' | COLOR_DIALOG_INPUT, vMIXED,
20, 0, SCST_TGT_NAME_LEN, FALSE, FALSE);
if (!tgt_name) {
errorDialog(main_cdk_screen, ENTRY_ERR_MSG, NULL);
break;
}
setCDKEntryBoxAttribute(tgt_name, COLOR_DIALOG_INPUT);
/* Relative target ID (scale) */
rel_tgt_id = newCDKScale(add_tgt_screen, (window_x + 1), (window_y + 7),
NULL, "</B>Relative Target ID: ", COLOR_DIALOG_SELECT,
7, 0, MIN_SCST_REL_TGT_ID, MAX_SCST_REL_TGT_ID,
1, 100, FALSE, FALSE);
if (!rel_tgt_id) {
errorDialog(main_cdk_screen, SCALE_ERR_MSG, NULL);
break;
}
setCDKScaleBackgroundAttrib(rel_tgt_id, COLOR_DIALOG_TEXT);
/* Buttons */
ok_button = newCDKButton(add_tgt_screen, (window_x + 16),
(window_y + 9), g_ok_cancel_msg[0], ok_cb, FALSE, FALSE);
if (!ok_button) {
errorDialog(main_cdk_screen, BUTTON_ERR_MSG, NULL);
break;
}
setCDKButtonBackgroundAttrib(ok_button, COLOR_DIALOG_INPUT);
cancel_button = newCDKButton(add_tgt_screen, (window_x + 26),
(window_y + 9), g_ok_cancel_msg[1], cancel_cb, FALSE, FALSE);
if (!cancel_button) {
errorDialog(main_cdk_screen, BUTTON_ERR_MSG, NULL);
break;
}
setCDKButtonBackgroundAttrib(cancel_button, COLOR_DIALOG_INPUT);
/* Allow user to traverse the screen */
refreshCDKScreen(add_tgt_screen);
traverse_ret = traverseCDKScreen(add_tgt_screen);
/* User hit 'OK' button */
if (traverse_ret == 1) {
/* Turn the cursor off (pretty) */
curs_set(0);
/* Check the entry field for bad characters */
if (!checkInputStr(main_cdk_screen, INIT_CHARS,
getCDKEntryValue(tgt_name)))
break;
/* Add the target to the target group */
snprintf(attr_path, MAX_SYSFS_PATH_SIZE,
"%s/device_groups/%s/target_groups/%s/mgmt",
SYSFS_SCST_TGT, dev_grp_name, tgt_grp_name);
snprintf(attr_value, MAX_SYSFS_ATTR_SIZE, "add %s",
getCDKEntryValue(tgt_name));
if ((temp_int = writeAttribute(attr_path, attr_value)) != 0) {
SAFE_ASPRINTF(&error_msg,
"Couldn't add SCST (ALUA) target to target group: %s",
strerror(temp_int));
errorDialog(main_cdk_screen, error_msg, NULL);
FREE_NULL(error_msg);
break;
}
/* Set the relative target ID */
snprintf(attr_path, MAX_SYSFS_PATH_SIZE,
"%s/device_groups/%s/target_groups/%s/%s/rel_tgt_id",
SYSFS_SCST_TGT, dev_grp_name, tgt_grp_name,
getCDKEntryValue(tgt_name));
snprintf(attr_value, MAX_SYSFS_ATTR_SIZE, "%d",
getCDKScaleValue(rel_tgt_id));
if ((temp_int = writeAttribute(attr_path, attr_value)) != 0) {
SAFE_ASPRINTF(&error_msg, SET_REL_TGT_ID_ERR, strerror(temp_int));
errorDialog(main_cdk_screen, error_msg, NULL);
FREE_NULL(error_msg);
break;
}
}
break;
}
/* Done */
for (i = 0; i < ADD_TGT_INFO_LINES; i++)
FREE_NULL(add_tgt_info_msg[i]);
if (add_tgt_screen != NULL) {
destroyCDKScreenObjects(add_tgt_screen);
destroyCDKScreen(add_tgt_screen);
delwin(add_tgt_window);
}
return;
}
int my_traverseCDKScreen (CDKSCREEN *screen)
{
CDKOBJS *curobj = NULL;
// Get the focus
curobj = getCDKFocusCurrent(screen);
// If we didn't have one, or it was invalid, pick first one.
if (!curobj)
curobj = switchFocus (setCDKFocusNext (screen), 0);
// Still no focus, bail.
if (curobj == 0)
return 0;
refreshDataCDKScreen (screen);
screen->exitStatus = CDKSCREEN_NOEXIT;
while ((curobj != 0) && (screen->exitStatus == CDKSCREEN_NOEXIT))
{
int key;
/* I want ASYNC, but for some reason you can't set this
* globally */
// PreProcess can change Focus, we need to detect this
if (getCDKFocusCurrent(screen) != curobj) {
curobj = getCDKFocusCurrent(screen);
if (!curobj) break;
}
wtimeout(curobj->inputWindow, 350);
key = getcCDKObject (curobj);
switch (key)
{
case KEY_BTAB:
{
curobj = switchFocus (setCDKFocusPrevious (screen), curobj);
break;
}
case KEY_TAB:
{
curobj = switchFocus (setCDKFocusNext (screen), curobj);
break;
}
case KEY_F(10):
{
/* save data and exit */
exitOKCDKScreen (screen);
break;
}
case CTRL('X'):
{
exitCancelCDKScreen (screen);
break;
}
case CTRL('R'):
{
/* reset data to defaults */
resetCDKScreen (screen);
setFocus (curobj);
break;
}
case CDK_REFRESH:
{
/* redraw screen */
refreshCDKScreen (screen);
setFocus (curobj);
break;
}
case KEY_ESC:
{
/* find and enable drop down menu */
int j;
for (j = 0; j < screen->objectCount; ++j)
if (ObjTypeOf (screen->object[j]) == vMENU)
{
curobj = handleMenu (screen, screen->object[j], curobj);
break;
}
break;
}
/* wgetch() returns ERR if we timedout */
case ERR:
return -1;
break;
default:
{
InjectObj (curobj, key);
break;
}
}
}
if (screen->exitStatus == CDKSCREEN_EXITOK)
{
saveDataCDKScreen (screen);
return 1;
}
else
return 0;
}
bool ConfParams()
{
param_entry_s *pFirstParam = NULL;
std::vector<char *> ParamItems;
for (std::list<command_entry_s *>::iterator p=InstallInfo.command_entries.begin();p!=InstallInfo.command_entries.end();
p++)
{
for (std::map<std::string, param_entry_s *>::iterator p2=(*p)->parameter_entries.begin();
p2!=(*p)->parameter_entries.end();p2++)
{
if (!pFirstParam) pFirstParam = p2->second;
ParamItems.push_back(MakeCString(p2->first));
}
}
if (!pFirstParam) return true; // No command entries...no need for this screen
char *title = CreateText("<C></B/29>%s<!29!B>", GetTranslation("Configure parameters"));
char *buttons[3] = { GetTranslation("Edit parameter"), GetTranslation("Continue"), GetTranslation("Cancel") };
ButtonBar.Clear();
ButtonBar.AddButton("TAB", "Next button");
ButtonBar.AddButton("ENTER", "Activate button");
ButtonBar.AddButton("Arrows", "Navigate menu");
ButtonBar.AddButton("A", "About");
ButtonBar.AddButton("ESC", "Exit program");
ButtonBar.Draw();
CCDKButtonBox ButtonBox(CDKScreen, CENTER, GetDefaultHeight()-1, 1, GetDefaultWidth(), 0, 1, 3, buttons, 3);
ButtonBox.SetBgColor(5);
CCDKScroll ScrollList(CDKScreen, getbegx(ButtonBox.GetBBox()->win), 2, getbegy(ButtonBox.GetBBox()->win)-1,
GetDefaultWidth()/2, RIGHT,
title, &ParamItems[0], ParamItems.size());
ScrollList.SetBgColor(5);
ScrollList.Bind('a', ShowAboutK);
const int defh = 3;
CCDKSWindow DescWindow(CDKScreen, (getbegx(ScrollList.GetScroll()->win) + getmaxx(ScrollList.GetScroll()->win))-1, 2,
getmaxy(ScrollList.GetScroll()->win)-defh-1, (GetDefaultWidth()/2)+1, CreateText("<C></B/29>%s<!29!B>",
GetTranslation("Description")), 30);
DescWindow.SetBgColor(5);
DescWindow.AddText(GetTranslation(pFirstParam->description));
CCDKSWindow DefWindow(CDKScreen, (getbegx(ScrollList.GetScroll()->win) + getmaxx(ScrollList.GetScroll()->win))-1,
getmaxy(DescWindow.GetSWin()->win), defh, (GetDefaultWidth()/2)+1, NULL, 4);
DefWindow.SetBgColor(5);
const char *str = pFirstParam->defaultval.c_str();
if (pFirstParam->param_type == PTYPE_BOOL)
{
if (!strcmp(str, "true")) str = GetTranslation("Enabled");
else str = GetTranslation("Disabled");
}
DefWindow.AddText(CreateText("</B/29>%s:<!29!B> %s", GetTranslation("Default"), str), false);
DefWindow.AddText(CreateText("</B/29>%s:<!29!B> %s", GetTranslation("Current"), str), false);
setCDKScrollLLChar(ScrollList.GetScroll(), ACS_LTEE);
setCDKScrollLRChar(ScrollList.GetScroll(), ACS_BTEE);
setCDKScrollURChar(ScrollList.GetScroll(), ACS_TTEE);
setCDKSwindowULChar(DescWindow.GetSWin(), ACS_TTEE);
setCDKSwindowLLChar(DescWindow.GetSWin(), ACS_LTEE);
setCDKSwindowLRChar(DescWindow.GetSWin(), ACS_RTEE);
setCDKSwindowURChar(DefWindow.GetSWin(), ACS_RTEE);
setCDKSwindowLRChar(DefWindow.GetSWin(), ACS_RTEE);
setCDKButtonboxULChar(ButtonBox.GetBBox(), ACS_LTEE);
setCDKButtonboxURChar(ButtonBox.GetBBox(), ACS_RTEE);
ButtonBox.Draw();
DescWindow.Draw();
DefWindow.Draw();
void *Data[4] = { &DescWindow, &DefWindow, &ScrollList, &ParamItems };
setCDKScrollPreProcess(ScrollList.GetScroll(), ScrollParamMenuK, &Data);
ScrollList.Bind(KEY_TAB, SwitchButtonK, ButtonBox.GetBBox());
bool success = false;
while(1)
{
int selection = ScrollList.Activate();
if (ScrollList.ExitType() == vNORMAL)
{
if (ButtonBox.GetCurrent() == 1)
{
success = true;
break;
}
else if (ButtonBox.GetCurrent() == 2)
{
success = false;
break;
}
param_entry_s *pParam = GetParamByName(ParamItems[selection]);
if (pParam->param_type == PTYPE_DIR)
{
CFileDialog filedialog(GetFirstValidDir(pParam->value),
CreateText("<C>%s", GetTranslation("Select a directory")), true, false);
if (filedialog.Activate()) pParam->value = filedialog.Result();
filedialog.Destroy();
refreshCDKScreen(CDKScreen);
}
else if (pParam->param_type == PTYPE_STRING)
{
CCDKEntry entry(CDKScreen, CENTER, CENTER, GetTranslation("Please enter new value"), "", 40, 0, 256);
entry.SetBgColor(26);
entry.SetValue(pParam->value);
const char *newval = entry.Activate();
if ((entry.ExitType() == vNORMAL) && newval)
pParam->value = newval;
// Restore screen
entry.Destroy();
refreshCDKScreen(CDKScreen);
}
else
{
std::vector<char *> chitems;
int cur = 0;
if (pParam->param_type == PTYPE_BOOL)
{
chitems.push_back(GetTranslation("Disable"));
chitems.push_back(GetTranslation("Enable"));
cur = (pParam->value == "true") ? 1 : 0;
}
else
{
int i = 0;
for (std::list<std::string>::iterator it=pParam->options.begin(); it!=pParam->options.end();it++, i++)
{
chitems.push_back(GetTranslation(MakeCString(*it)));
if (*it == pParam->value)
cur = i;
}
}
CCDKScroll chScrollList(CDKScreen, CENTER, CENTER, 6, 30, RIGHT,
GetTranslation("Please choose new value"), &chitems[0], chitems.size());
chScrollList.SetBgColor(26);
chScrollList.SetCurrent(cur);
int chsel = chScrollList.Activate();
if (chScrollList.ExitType() == vNORMAL)
{
if (pParam->param_type == PTYPE_BOOL)
{
if (!strcmp(chitems[chsel], GetTranslation("Enable"))) pParam->value = "true";
else pParam->value = "false";
}
else
pParam->value = chitems[chsel];
}
chScrollList.Destroy();
refreshCDKScreen(CDKScreen);
}
DefWindow.Clear();
DefWindow.AddText(CreateText("</B/29>%s:<!29!B> %s", GetTranslation("Default"), GetParamDefault(pParam)),
false);
DefWindow.AddText(CreateText("</B/29>%s:<!29!B> %s", GetTranslation("Current"), GetParamValue(pParam)),
false);
}
else
{
success = false;
break;
}
}
return success;
}
/*
* This allows the user to use the cursor keys to adjust the
* position of the widget.
*/
void positionCDKButton (CDKBUTTON *button)
{
/* Declare some variables. */
int origX = getbegx (button->win);
int origY = getbegy (button->win);
chtype key = (chtype)0;
boolean functionKey;
/* Let them move the widget around until they hit return. */
while (key != KEY_ENTER)
{
key = (chtype)getchCDKObject (ObjOf (button), &functionKey);
if (key == KEY_UP || key == '8')
{
if (getbegy (button->win) > 0)
{
moveCDKButton (button, 0, -1, TRUE, TRUE);
}
else
{
BEEP ();
}
}
else if (key == KEY_DOWN || key == '2')
{
if (getbegy (button->win) + getmaxy (button->win) <
getmaxy (WindowOf (button)) - 1)
{
moveCDKButton (button, 0, 1, TRUE, TRUE);
}
else
{
BEEP ();
}
}
else if (key == KEY_LEFT || key == '4')
{
if (getbegx (button->win) > 0)
{
moveCDKButton (button, -1, 0, TRUE, TRUE);
}
else
{
BEEP ();
}
}
else if (key == KEY_RIGHT || key == '6')
{
if (getbegx (button->win) + getmaxx (button->win) < getmaxx
(WindowOf (button)) - 1)
{
moveCDKButton (button, 1, 0, TRUE, TRUE);
}
else
{
BEEP ();
}
}
else if (key == '7')
{
if (getbegy (button->win) > 0 && getbegx (button->win) > 0)
{
moveCDKButton (button, -1, -1, TRUE, TRUE);
}
else
{
BEEP ();
}
}
else if (key == '9')
{
if (getbegx (button->win) + getmaxx (button->win) < getmaxx
(WindowOf (button)) - 1 &&
getbegy (button->win) > 0)
{
moveCDKButton (button, 1, -1, TRUE, TRUE);
}
else
{
BEEP ();
}
}
else if (key == '1')
{
if (getbegx (button->win) > 0 && getbegx (button->win) +
getmaxx (button->win) < getmaxx (WindowOf (button)) - 1)
{
moveCDKButton (button, -1, 1, TRUE, TRUE);
}
else
{
BEEP ();
}
}
else if (key == '3')
{
if (getbegx (button->win) + getmaxx (button->win) <
getmaxx (WindowOf (button)) - 1
&& getbegy (button->win) + getmaxy (button->win) <
getmaxy (WindowOf (button)) - 1)
{
moveCDKButton (button, 1, 1, TRUE, TRUE);
}
else
{
BEEP ();
}
}
else if (key == '5')
{
moveCDKButton (button, CENTER, CENTER, FALSE, TRUE);
}
else if (key == 't')
{
moveCDKButton (button, getbegx (button->win), TOP, FALSE, TRUE);
}
else if (key == 'b')
{
moveCDKButton (button, getbegx (button->win), BOTTOM, FALSE, TRUE);
}
else if (key == 'l')
{
moveCDKButton (button, LEFT, getbegy (button->win), FALSE, TRUE);
}
else if (key == 'r')
{
moveCDKButton (button, RIGHT, getbegy (button->win), FALSE, TRUE);
}
else if (key == 'c')
{
moveCDKButton (button, CENTER, getbegy (button->win), FALSE, TRUE);
}
else if (key == 'C')
{
moveCDKButton (button, getbegx (button->win), CENTER, FALSE, TRUE);
}
else if (key == CDK_REFRESH)
{
eraseCDKScreen (ScreenOf (button));
refreshCDKScreen (ScreenOf (button));
}
else if (key == KEY_ESC)
{
moveCDKButton (button, origX, origY, FALSE, TRUE);
}
else if (key != KEY_ENTER)
{
BEEP ();
}
}
}
/*
* This injects a single character into the dialog widget.
*/
int injectCDKDialog (CDKDIALOG *dialog, chtype input)
{
int firstButton = 0;
int lastButton = dialog->buttonCount - 1;
int ppReturn = 1;
/* Set the exit type. */
dialog->exitType = vEARLY_EXIT;
/* Check if there is a pre-process function to be called. */
if (dialog->preProcessFunction != 0)
{
ppReturn = dialog->preProcessFunction (vDIALOG, dialog, dialog->preProcessData, input);
}
/* Should we continue? */
if (ppReturn != 0)
{
/* Check for a key binding. */
if (checkCDKObjectBind (vDIALOG, dialog, input) != 0)
{
dialog->exitType = vESCAPE_HIT;
return -1;
}
else
{
switch (input)
{
case KEY_LEFT : case CDK_PREV :
if (dialog->currentButton == firstButton)
{
dialog->currentButton = lastButton;;
}
else
{
dialog->currentButton--;
}
break;
case KEY_RIGHT : case CDK_NEXT : case KEY_TAB : case ' ' :
if (dialog->currentButton == lastButton)
{
dialog->currentButton = firstButton;
}
else
{
dialog->currentButton++;
}
break;
case KEY_UP : case KEY_DOWN :
Beep();
break;
case CDK_REFRESH :
eraseCDKScreen (ScreenOf(dialog));
refreshCDKScreen (ScreenOf(dialog));
break;
case KEY_ESC :
dialog->exitType = vESCAPE_HIT;
return -1;
case KEY_RETURN : case KEY_ENTER :
dialog->exitType = vNORMAL;
return dialog->currentButton;
default :
break;
}
}
/* Should we call a post-process? */
if (dialog->postProcessFunction != 0)
{
dialog->postProcessFunction (vDIALOG, dialog, dialog->postProcessData, input);
}
}
/* Redraw the buttons. */
drawCDKDialogButtons (dialog);
wrefresh (dialog->win);
/* Exit the dialog box. */
dialog->exitType = vEARLY_EXIT;
return -1;
}
int main (int argc, char **argv)
{
/* *INDENT-EQLS* */
CDKSCREEN *cdkscreen = 0;
CDKMENTRY *widget = 0;
char *info = 0;
const char *label = "</R>Message";
const char *title =
"<C></5>Enter a message (\".\" to exit).<!5>\n"
"<C>It can be </3>multi<!3>-line!";
int boxWidth;
CDK_PARAMS params;
CDKparseParams (argc, argv, ¶ms, "w:h:l:" CDK_MIN_PARAMS);
cdkscreen = initCDKScreen (NULL);
/* Start CDK Colors. */
initCDKColor ();
/* Set up the multi-line entry field. */
boxWidth = CDKparamValue (¶ms, 'w', 40);
widget = newCDKMentry (cdkscreen,
CDKparamValue (¶ms, 'X', CENTER),
CDKparamValue (¶ms, 'Y', CENTER),
title, label, A_BOLD, '.', vMIXED,
boxWidth,
CDKparamValue (¶ms, 'h', 5),
CDKparamValue (¶ms, 'l', 20),
0,
CDKparamValue (¶ms, 'N', TRUE),
CDKparamValue (¶ms, 'S', FALSE));
/* Is the object null? */
if (widget == 0)
{
/* Shut down CDK. */
destroyCDKScreen (cdkscreen);
endCDK ();
printf ("Cannot create CDK object. Is the window too small?\n");
ExitProgram (EXIT_FAILURE);
}
refreshCDKScreen (cdkscreen);
for (;;)
{
info = getCdkTitle (ObjOf (widget));
setCDKMentry (widget, info, 0, TRUE);
free (info);
activateCDKMentry (widget, 0);
if (strlen (widget->info) > 1)
{
setCdkTitle (ObjOf (widget), widget->info, getmaxx (widget->win));
eraseCDKScreen (ScreenOf (widget));
drawCDKScreen (ScreenOf (widget));
}
else
{
break;
}
}
destroyCDKMentry (widget);
destroyCDKScreen (cdkscreen);
endCDK ();
ExitProgram (EXIT_SUCCESS);
}
/*
* This injects a single character into the widget.
*/
static int _injectCDKScroll (CDKOBJS *object, chtype input)
{
CDKSCROLL *widget = (CDKSCROLL *)object;
int ppReturn = 1;
int ret = unknownInt;
bool complete = FALSE;
/* Set the exit type for the widget. */
setExitType (widget, 0);
/* Draw the scrolling list */
drawCDKScrollList (widget, ObjOf (widget)->box);
/* Check if there is a pre-process function to be called. */
if (PreProcessFuncOf (widget) != 0)
{
/* Call the pre-process function. */
ppReturn = PreProcessFuncOf (widget) (vSCROLL,
widget,
PreProcessDataOf (widget),
input);
}
/* Should we continue? */
if (ppReturn != 0)
{
/* Check for a predefined key binding. */
if (checkCDKObjectBind (vSCROLL, widget, input) != 0)
{
checkEarlyExit (widget);
complete = TRUE;
}
else
{
switch (input)
{
case KEY_UP:
scroller_KEY_UP (widget);
break;
case KEY_DOWN:
scroller_KEY_DOWN (widget);
break;
case KEY_RIGHT:
scroller_KEY_RIGHT (widget);
break;
case KEY_LEFT:
scroller_KEY_LEFT (widget);
break;
case KEY_PPAGE:
scroller_KEY_PPAGE (widget);
break;
case KEY_NPAGE:
scroller_KEY_NPAGE (widget);
break;
case KEY_HOME:
scroller_KEY_HOME (widget);
break;
case KEY_END:
scroller_KEY_END (widget);
break;
case '$':
widget->leftChar = widget->maxLeftChar;
break;
case '|':
widget->leftChar = 0;
break;
case KEY_ESC:
setExitType (widget, input);
complete = TRUE;
break;
case KEY_ERROR:
setExitType (widget, input);
complete = TRUE;
break;
case CDK_REFRESH:
eraseCDKScreen (ScreenOf (widget));
refreshCDKScreen (ScreenOf (widget));
break;
case KEY_TAB:
case KEY_ENTER:
setExitType (widget, input);
ret = widget->currentItem;
complete = TRUE;
break;
default:
break;
}
}
/* Should we call a post-process? */
if (!complete && (PostProcessFuncOf (widget) != 0))
{
PostProcessFuncOf (widget) (vSCROLL,
widget,
PostProcessDataOf (widget),
input);
}
}
if (!complete)
{
drawCDKScrollList (widget, ObjOf (widget)->box);
setExitType (widget, 0);
}
fixCursorPosition (widget);
ResultOf (widget).valueInt = ret;
return (ret != unknownInt);
}
int main()
{
char *mesg[4],*infobuf[2];
char *shared_memory;
char string[1024],temp[1024];
FILE *file;
Nodeinfo *mynode;
int segment_id, sem_id, i = 1024, k = 1024, line, j, count;
void *buf;
signal(SIGTERM, cleanup_handler);
signal(SIGINT, cleanup_handler);
req.tv_nsec = 5000000;
cursesWin = initscr();
cdkscreen = initCDKScreen(cursesWin);
initCDKColor();
sprintf(temp,"<C></B/3>Process Migration - GUI for Statistics and Testing");
mesg[0] = copyChar(temp);
title = newCDKLabel(cdkscreen, CENTER, TOP, mesg,1,1,0);
setCDKLabel (title, mesg, 1, 1);
drawCDKLabel (title, 1);
freeChar (mesg[0]);
loadDaemon = newCDKSwindow (cdkscreen, (COLS - 50) * 0.10, (LINES - 12) * 0.40, 12, 50, "<C></B/5>Load Daemon", 1000, 1, 0);
commsDaemon = newCDKSwindow (cdkscreen, (COLS - 50) * 0.90, (LINES - 12) * 0.40, 12, 50, "<C></B/5>Communication Daemon", 1000, 1, 0);
migrateDaemon = newCDKSwindow (cdkscreen, (COLS - 50) * 0.10, (LINES - 12) * 0.90, 12, 50, "<C></B/5>Migration Control Daemon", 1000, 1, 0);
extraInfo = newCDKSwindow (cdkscreen, (COLS - 50) * 0.90, (LINES - 12) * 0.90, 12, 50, "<C></B/5>Information", 1000, 1, 0);
//setCDKSwindowBackgroundColor(loadDaemon, "</5>");
//setCDKSwindowBackgroundColor(commsDaemon, "</5>");
//setCDKSwindowBackgroundColor(migrateDaemon, "</5>");
//setCDKSwindowBackgroundColor(extraInfo, "</5>");
file = fopen("/var/log/load","r");
while(fgets(string, 1025, file) != NULL) {
substr(&temp[0],&string[0]);
addCDKSwindow (loadDaemon, temp, BOTTOM);
}
fclose(file);
file = fopen("/var/log/migrate","r");
while(fgets(string, 1025, file) != NULL) {
substr(&temp[0],&string[0]);
addCDKSwindow (migrateDaemon, temp, BOTTOM);
}
fclose(file);
buf = malloc(33);
file = fopen(INFO_SHM_ID_PATH,"r");
fgets(string,33,file);
segment_id = atoi(string);
fclose(file);
file = fopen(INFO_SEM_ID_PATH,"r");
fgets(string,33,file);
sem_id = atoi(string);
fclose(file);
info = newCDKLabel(cdkscreen, 0, (LINES - 5) * 0.15, infobuf,3,0,0);
shared_memory = (void *) shmat(segment_id, 0, 0);
//setCDKLabelBackgroundColor(info, "</55>");
refreshCDKScreen(cdkscreen);
binary_semaphore_post(sem_id);
cp_loadlog();
cp_migratelog();
for(;;) {
if(i-- == 0) {
cp_loadlog();
i = 1024;
}
file = popen("diff /tmp/migrate/load.temp /var/log/load | sed 1d | wc -l","r");
strcpy(string,"\0");
fgets(string, 1025, file);
count = atoi(string);
pclose(file);
sprintf(string,"count: %d",count);
if(count != 0) {
file = popen("diff /tmp/migrate/load.temp /var/log/load | sed 1d","r");
for(j = 0; j < count; j++) {
fgets(string, 1025, file);
substr(&temp[0],&string[0]);
addCDKSwindow (loadDaemon, temp, BOTTOM);
}
pclose(file);
i = 0;
}
/*if(k-- == 0) {
cp_migratelog();
k = 1024;
}
file = popen("diff /tmp/migrate/migrate.temp /var/log/migrate | sed 1d | wc -l","r");
strcpy(string,"\0");
fgets(string, 1025, file);
count = atoi(string);
pclose(file);
sprintf(string,"count: %d",count);
if(count != 0) {
file = popen("diff /tmp/migrate/migrate.temp /var/log/migrate | sed 1d","r");
for(j = 0; j < count; j++) {
fgets(string, 1025, file);
substr(&temp[0],&string[0]);
addCDKSwindow (migrateDaemon, temp, BOTTOM);
}
pclose(file);
k = 0;
}*/
binary_semaphore_wait(sem_id);
memcpy(buf, shared_memory, 33);
binary_semaphore_post(sem_id);
mynode = nodeinfo__unpack(NULL, 33, buf);
if(mynode == NULL) {
fprintf(stderr,"error unpacking message\n");
exit(1);
}
sprintf(temp,"\t\t\t\t\t\t\t</B/U/7>STATISTICS");
infobuf[0] = copyChar(temp);
sprintf(temp,"\t</B>Load:<!B> %0.2f\t</B>No. of peers connected:<!B> %d\t</B>No. of processes migrated:<!B> %d\t</B>No. of processes accepted:<!B> %d\t",mynode->load,mynode->np,mynode->npm,mynode->npa);
infobuf[1] = copyChar(temp);
sprintf(temp,"\t\t\t\t</B>Upper Threshold:<!B> %.2f\t</B>Lower Threshold:<!B> %.2f",mynode->uthresh,mynode->lthresh);
infobuf[2] = copyChar(temp);
setCDKLabel (info, infobuf, 3, 0);
drawCDKLabel (info, 0);
freeChar (infobuf[0]);
freeChar (infobuf[1]);
freeChar (infobuf[2]);
sleep(1);
}
exit(0);
}
