/*--------------------------------------------------------------------------*/
void PegMenuButton::AddSubMenu(BOOL bVertical)
{
PegMessage NewMessage;
NewMessage.Rect = mpSubMenu->GetMinSize();
if (bVertical)
{
NewMessage.Rect.MoveTo(mReal.wLeft, mReal.wBottom + 2);
}
else
{
NewMessage.Rect.MoveTo(mReal.wRight, mReal.wTop - 4);
}
// do some quick vertical positioning checks:
if (NewMessage.Rect.wBottom >= Presentation()->mReal.wBottom)
{
if (bVertical)
{
if (NewMessage.Rect.Height() < mReal.wTop - 1)
{
NewMessage.Rect.Shift(0,
-(mReal.Height() + NewMessage.Rect.Height() + 2));
}
}
else
{
NewMessage.Rect.Shift(0,
Presentation()->mReal.wBottom - NewMessage.Rect.wBottom - 1);
}
}
// do some quick horizontal positioning checks:
if (NewMessage.Rect.wRight > Presentation()->mReal.wRight)
{
if (bVertical)
{
NewMessage.Rect.Shift(Presentation()->mReal.wRight -
NewMessage.Rect.wRight, 0);
}
else
{
NewMessage.Rect.Shift(
-(mReal.Width() + NewMessage.Rect.Width() + 1), 0);
}
}
NewMessage.wType = PM_SIZE;
mpSubMenu->Message(NewMessage);
Presentation()->Add(mpSubMenu);
mbSubVisible = TRUE;
}
/*--------------------------------------------------------------------------*/
SIGNED HelpMenuClass::Message(const PegMessage &Mesg)
{
MainMenuClass *pMainWindow;
switch (Mesg.wType)
{
case PM_KEYLEFT:
case PM_KEYRIGHT:
switch(Mesg.iData)
{
case HelpSelectionButtonID:
if (Mesg.wType == PM_KEYRIGHT)
{
}
else
{
}
DisplayHelp(); /* setup help window */
break;
}
break;
case PM_CLOSE:
/* left key = close = go back to previous menu */
Destroy(this);
pMainWindow = (MainMenuClass*) Presentation()->Find(MAIN_MENU_ID);
pMainWindow->SetBitmap(&gbMainBitmap);
break;
default:
return PegWindow::Message(Mesg);
}
return 0;
}
int main (int argc, char **argv)
{
vector<Story> corpus;
map<int, string> glossaryIntToString;
map<string, int> glossaryStringToInt;
vector<Story> firstStories;
string tkn_file = "Dataset/mttkn/20030402_0530_0700_CNA_MAN.mttkn";
string bnd_file = "Dataset/mttkn_bnd/20030402_0530_0700_CNA_MAN.mttkn_bnd";
DataPreprocessing (corpus, glossaryIntToString, glossaryStringToInt, tkn_file, bnd_file);
cout << "corpus.size() = " << corpus.size () << endl;
assert (corpus.size () > 0);
int numOfTopics = 0;
TopicDetection (corpus, numOfTopics);
cout << "numOfTopics = " << numOfTopics << endl;
assert (numOfTopics > 0);
FirstStoryDetection (firstStories, corpus, numOfTopics);
cout << "firstStories.size() = " << firstStories.size () << endl;
assert (firstStories.size () == numOfTopics);
Presentation (firstStories, corpus, glossaryIntToString, numOfTopics);
return 0;
}
void MyMainFrame::setActiveWindow(MyWindow* win)
{
if(containsWindow(win)==false) addWindow(win);
else
{
m_activeWin = win;
Presentation()->MoveFocusTree(win);
}
}
void SetupMenuClass::BackToPreviousMenu(void)
{
ServiceMenuClass *pServiceWindow;
Destroy(this);
pServiceWindow = (ServiceMenuClass*) Presentation()->Find(SERVICE_MENU_ID);
// pServiceWindow->SetBitmap(&gbMainBitmap);
pServiceWindow->SetBackgroundColor(PegBlueTransparent);
}
void PictureMenu::ProcessUpDownKey()
{
switch(m_nCurrentSubWndID)
{
case ID_PictureMenu_Button_Brightness:
{
m_pTVHelpWnd->ShowHelpString(LS(SID_PictureMenu_Prompt_Brightness), NEWMENU_BUTTON_TYPE);
m_pPictuerMenuButtonBright->SetToolTip(m_pToolTip);
m_pPictuerMenuButtonBright->ShowTip();
break;
}
case ID_PictureMenu_Button_Contrast:
{
m_pTVHelpWnd->ShowHelpString(LS(SID_PictureMenu_Prompt_Contrast), NEWMENU_BUTTON_TYPE);
m_pPictureMenuButtonContrast->SetToolTip(m_pToolTip);
m_pPictureMenuButtonContrast->ShowTip();
break;
}
case ID_PictureMenu_Button_Tint:
{
m_pTVHelpWnd->ShowHelpString(LS(SID_PictureMenu_Prompt_Tint), NEWMENU_BUTTON_TYPE);
m_pPictureMenuButtonTint->SetToolTip(m_pToolTip);
m_pPictureMenuButtonTint->ShowTip();
break;
}
case ID_PictureMenu_Button_Sharp:
{
m_pTVHelpWnd->ShowHelpString(LS(SID_PictureMenu_Prompt_Sharpness), NEWMENU_BUTTON_TYPE);
m_pPictureMenuButtonSharp->SetToolTip(m_pToolTip);
m_pPictureMenuButtonSharp->ShowTip();
break;
}
case ID_PictureMenu_Button_Color:
{
m_pTVHelpWnd->ShowHelpString(LS(SID_PictureMenu_Prompt_Color), NEWMENU_BUTTON_TYPE);
m_pPictureMenuButtonColor->SetToolTip(m_pToolTip);
m_pPictureMenuButtonColor->ShowTip();
break;
}
case ID_PictureMenu_Button_ColorTemp:
{
m_pTVHelpWnd->ShowHelpString(LS(SID_PictureMenu_Prompt_ColorTemp), NEWMENU_BUTTON_TYPE);
m_pPictureMenuButtonColorTemp->SetToolTip(m_pToolTip);
m_pPictureMenuButtonColorTemp->ShowTip();
break;
}
default:
{
//assert(FALSE);
}
}
Presentation()->Draw();
}
PegStatusBar* MyMainFrame::getStatusBar()
{
if(m_statusBar==NULL)
{
m_statusBar = new PegStatusBar();
m_statusBar->RemoveStatus(PSF_ACCEPTS_FOCUS);
m_statusBar->AddTextField(1, 1);
Presentation()->AddToEnd(m_statusBar);
}
return m_statusBar;
}
TEST_F(StateSubjectTest,testDeleteState){
this->stateSubject.deleteState();
ASSERT_EQ(NULL,this->stateSubject.state);
ERModel erModel;
Presentation presentation = Presentation(&erModel);
GraphicalPresentation graphicalPresentation = GraphicalPresentation(&presentation);
this->stateSubject.state = new AddNodeState(StateID::AddAttributeState,&graphicalPresentation);
this->stateSubject.deleteState();
ASSERT_EQ(NULL,this->stateSubject.state);
}
void MyMainFrame::showKeypad(bool on)
{
if( ! (on ^ keypadOn()) ) return;
m_keyPadOn = on;
if(on)
{
Presentation()->AddToEnd(getKeypad());
Resize(m_smallRect);
resizeClient();
Presentation()->Draw();
}
else
{
Presentation()->Remove(getKeypad());
Resize(m_bigRect);
resizeClient();
Presentation()->Draw();
}
}
/*--------------------------------------------------------------------------*/
SIGNED PegGroup::Message(const PegMessage &Mesg)
{
switch (Mesg.wType)
{
case PM_SHOW:
PegThing::Message(Mesg);
muColors[PCI_NORMAL] = Parent()->muColors[PCI_NORMAL];
#if defined(PEG_KEYBOARD_SUPPORT) && defined(PEG_TAB_KEY_SUPPORT)
SetDefaultTabLinks();
#endif
break;
#if defined(PEG_KEYBOARD_SUPPORT)
case PM_GAINED_KEYBOARD:
MoveFocusToFirstClientChild();
break;
#if defined(PEG_TAB_KEY_SUPPORT)
// if tabbing is supported, the group gets an arrow key input, it means that
// the user has reached the limit of navigation within the group. Don't allow
// moving outside the group if TAB key is supported:
case PM_KEY:
if (Mesg.iData == PK_LEFT ||
Mesg.iData == PK_RIGHT ||
Mesg.iData == PK_LNUP ||
Mesg.iData == PK_LNDN)
{
break;
}
return PegThing::Message(Mesg);
#endif
#else
case PM_CURRENT:
if (Presentation()->GetCurrentThing() == this)
{
MoveFocusToFirstClientChild();
}
PegThing::Message(Mesg);
break;
#endif
default:
PegThing::Message(Mesg);
break;
}
return 0;
}
void MyMainFrame::addWindow(MyWindow* win)
{
if(win==NULL) return;
if(win->posCorrected()==false) placeInClient(win, win->mReal.wLeft, win->mReal.wTop, false);
m_client->Add(win);
if(m_activeWin) m_otherWin.Insert(m_activeWin);
m_activeWin = win;
Presentation()->MoveFocusTree(win);
PegMessageWindow* pWin = new PegMessageWindow("","");
delete pWin;
// Yes, I know... this is stupid.
// But don't ask me why the system can freeze if you don't write it...
}
MyMainFrame::~MyMainFrame(void)
{
Destroy(m_client);
if(m_titleBar) destroyTitle();
if(m_menuBar) destroyMenuBar();
if(m_toolBar) destroyToolBar();
if(m_statusBar)
{
Presentation()->Destroy(m_statusBar);
m_statusBar = NULL;
}
if(keypadOn()) showKeypad(false);
}
TEST_F(StateSubjectTest,testSwitchState){
ERModel erModel;
Presentation presentation = Presentation(&erModel);
GraphicalPresentation graphicalPresentation = GraphicalPresentation(&presentation);
this->stateSubject.switchState(StateID::AddAttributeState,&graphicalPresentation);
ASSERT_EQ(typeid(AddNodeState).name(),typeid(*this->stateSubject.state).name());
this->stateSubject.switchState(StateID::AddEntityState,&graphicalPresentation);
ASSERT_EQ(typeid(AddNodeState).name(),typeid(*this->stateSubject.state).name());
this->stateSubject.switchState(StateID::AddRelationShipState,&graphicalPresentation);
ASSERT_EQ(typeid(AddNodeState).name(),typeid(*this->stateSubject.state).name());
this->stateSubject.switchState(StateID::ConnectState,&graphicalPresentation);
ASSERT_EQ(typeid(ConnectState).name(),typeid(*this->stateSubject.state).name());
this->stateSubject.switchState(StateID::PointerState,&graphicalPresentation);
ASSERT_EQ(typeid(PointerState).name(),typeid(*this->stateSubject.state).name());
}
void MyMainFrame::removeWindow(MyWindow* win, bool destroy)
{
if(win==NULL) return;
if(win==m_activeWin)
{
if(m_otherWin.Count())
{
m_activeWin = (MyWindow*) m_otherWin.Get();
m_otherWin.Remove(m_activeWin);
Presentation()->MoveFocusTree(m_activeWin);
}
else m_activeWin = NULL;
}
else if(m_otherWin.Contains(win)) m_otherWin.Remove(win);
if(destroy) m_client->Destroy(win);
else m_client->Remove(win);
}
/*--------------------------------------------------------------------------*/
void PegWindow::Add(PegThing *Who, BOOL bDraw)
{
BOOL bSetFocus = TRUE;
if (Who->StatusIs(PSF_VISIBLE))
{
bSetFocus = FALSE;
}
if (Who != First())
{
PegThing::Add(Who, bDraw);
if (bSetFocus)
{
if (StatusIs(PSF_VISIBLE) && StatusIs(PSF_CURRENT) &&
Who->StatusIs(PSF_ACCEPTS_FOCUS) &&
!Who->StatusIs(PSF_NONCLIENT))
{
Presentation()->MoveFocusTree(Who);
}
}
}
}
/*--------------------------------------------------------------------------*/
void PegMenuButton::SendOwnerMessage(void)
{
if (mpSubMenu || !mpOwner || Parent()->Type() == TYPE_MENU_BAR)
{
return;
}
Presentation()->MoveFocusTree(mpOwner);
if (mwStyle & BF_CHECKABLE)
{
if (mwStyle & BF_CHECKED)
{
SetChecked(FALSE);
}
else
{
SetChecked(TRUE);
}
}
else
{
if (mwStyle & BF_DOTABLE)
{
RemoveSiblingDots();
SetDotted(TRUE);
}
else
{
if (Id())
{
PegMessage NewMessage(mpOwner, PEG_SIGNAL(Id(), PSF_CLICKED));
NewMessage.iData = Id();
NewMessage.pSource = this;
MessageQueue()->Push(NewMessage);
}
}
}
}
/*--------------------------------------------------------------------------*/
SIGNED PegWindow::Message(const PegMessage &Mesg)
{
SIGNED Result = 0;
PegMessage NewMessage;
switch(Mesg.wType)
{
case PM_POINTER_MOVE:
if (muMoveMode)
{
if (Mesg.Point.x != mMovePoint.x ||
Mesg.Point.y != mMovePoint.y)
{
DrawMoveFrame(TRUE);
mMovePoint = Mesg.Point;
DrawMoveFrame(FALSE);
}
}
else
{
if (StatusIs(PSF_SIZEABLE) && !mbMaximized)
{
UCHAR uTemp = BorderContains(Mesg.Point);
if (uTemp != mbShowPointer)
{
mbShowPointer = uTemp;
switch(uTemp)
{
case PMM_MOVELEFT:
case PMM_MOVERIGHT:
SetPointerType(PPT_HSIZE);
break;
case PMM_MOVETOP:
case PMM_MOVEBOTTOM:
SetPointerType(PPT_VSIZE);
break;
case PMM_MOVEUR:
case PMM_MOVELL:
SetPointerType(PPT_NESW_SIZE);
break;
case PMM_MOVEUL:
case PMM_MOVELR:
SetPointerType(PPT_NWSE_SIZE);
break;
default:
SetPointerType(PPT_NORMAL);
break;
}
}
}
}
break;
case PM_SHOW:
PegThing::Message(Mesg);
#if defined(PEG_KEYBOARD_SUPPORT) && defined(PEG_TAB_KEY_SUPPORT)
SetDefaultTabLinks();
#endif
if (muScrollMode & WSM_AUTOSCROLL)
{
CheckAutoScroll();
}
break;
#if defined(PEG_KEYBOARD_SUPPORT)
case PM_GAINED_KEYBOARD:
if (!StatusIs(PSF_KEEPS_CHILD_FOCUS))
{
MoveFocusToFirstClientChild();
}
break;
#else
case PM_CURRENT:
PegThing::Message(Mesg);
if (Presentation()->GetCurrentThing() == this &&
!StatusIs(PSF_KEEPS_CHILD_FOCUS))
{
MoveFocusToFirstClientChild();
}
break;
#endif
case PM_ADDICON:
AddIcon((PegIcon *) Mesg.pData);
break;
case PM_BEGIN_MOVE:
if (!muMoveMode && StatusIs(PSF_MOVEABLE))
{
muMoveMode = (UCHAR) Mesg.iData;
mbMoveFrame = FALSE;
CapturePointer();
mStartMove = Mesg.Point;
mMovePoint = mStartMove;
if (muMoveMode == PMM_MOVELR)
{
SetPointerType(PPT_NWSE_SIZE);
mbShowPointer = TRUE;
}
}
break;
case PM_POINTER_EXIT:
if (mbShowPointer)
{
SetPointerType(PPT_NORMAL);
mbShowPointer = 0;
}
PegThing::Message(Mesg);
break;
case PM_LBUTTONDOWN:
if (!muMoveMode && StatusIs(PSF_SIZEABLE) && !mbMaximized)
{
muMoveMode = BorderContains(Mesg.Point);
if (muMoveMode)
{
mbMoveFrame = FALSE;
CapturePointer();
mStartMove = Mesg.Point;
mMovePoint = mStartMove;
}
}
break;
case PM_LBUTTONUP:
if (muMoveMode)
{
DrawMoveFrame(TRUE);
SetPointerType(PPT_NORMAL);
ReleasePointer();
PegRect OldSize = mReal;
if (mStartMove.x == mMovePoint.x &&
mStartMove.y == mMovePoint.y)
{
muMoveMode = 0;
break; // didn't really move or size anything
}
PegRect NewSize = mReal;
int xShift = mMovePoint.x - mStartMove.x;
int yShift = mMovePoint.y - mStartMove.y;
switch(muMoveMode)
{
case PMM_MOVEALL:
NewSize.Shift(xShift, yShift);
break;
case PMM_MOVERIGHT:
NewSize.wRight += xShift;
break;
case PMM_MOVELEFT:
NewSize.wLeft += xShift;
break;
case PMM_MOVETOP:
NewSize.wTop += yShift;
break;
case PMM_MOVEBOTTOM:
NewSize.wBottom += yShift;
break;
case PMM_MOVEUL:
NewSize.wLeft += xShift;
NewSize.wTop += yShift;
break;
case PMM_MOVELL:
NewSize.wLeft += xShift;
NewSize.wBottom += yShift;
break;
case PMM_MOVEUR:
NewSize.wRight += xShift;
NewSize.wTop += yShift;
break;
case PMM_MOVELR:
NewSize.wRight += xShift;
NewSize.wBottom += yShift;
break;
}
CheckResizeRect(NewSize);
NewMessage.wType = PM_SIZE;
NewMessage.Rect = NewSize;
Message(NewMessage);
if (StatusIs(PSF_VISIBLE))
{
if (mReal.Contains(OldSize))
{
Draw();
}
else
{
Parent()->Draw();
}
}
muMoveMode = 0;
}
break;
case PM_VSCROLL:
MoveClientObjects(0, Mesg.iData - (SIGNED) Mesg.lData);
break;
case PM_HSCROLL:
MoveClientObjects(Mesg.iData - (SIGNED) Mesg.lData, 0);
break;
case PM_MAXIMIZE:
if (StatusIs(PSF_SIZEABLE))
{
mbMaximized = TRUE;
mRestore = mReal;
NewMessage.wType = PM_SIZE;
NewMessage.Rect = Parent()->mClient;
Message(NewMessage);
Draw();
}
break;
case PM_MINIMIZE:
if (StatusIs(PSF_SIZEABLE) && !IsModal())
{
NewMessage.wType = PM_ADDICON;
PegIcon *pIcon = new PegIcon(this, mpIconMap);
pIcon->Id(Id());
NewMessage.pData = pIcon;
NewMessage.pTarget = Parent();
MessageQueue()->Push(NewMessage);
Parent()->Remove(this);
}
break;
case PM_RESTORE:
if (StatusIs(PSF_SIZEABLE))
{
if (mbMaximized)
{
mbMaximized = FALSE;
NewMessage.wType = PM_SIZE;
NewMessage.Rect = mRestore;
Message(NewMessage);
Parent()->Draw();
}
}
break;
#ifdef PEG_KEYBOARD_SUPPORT
case PM_KEY:
if (Parent() == Presentation() &&
Mesg.iData == PK_F4 &&
(Mesg.lData & KF_CTRL))
{
NewMessage.wType = PM_CLOSE;
NewMessage.pTarget = this;
MessageQueue()->Push(NewMessage);
}
else
{
return PegThing::Message(Mesg);
}
break;
#endif
case PM_CLOSE:
Destroy(this);
return(IDB_CLOSE);
case PEG_SIGNAL(IDB_CLOSE, PSF_CLICKED):
case PEG_SIGNAL(IDB_OK, PSF_CLICKED):
case PEG_SIGNAL(IDB_CANCEL, PSF_CLICKED):
case PEG_SIGNAL(IDB_YES, PSF_CLICKED):
case PEG_SIGNAL(IDB_NO, PSF_CLICKED):
case PEG_SIGNAL(IDB_RETRY, PSF_CLICKED):
case PEG_SIGNAL(IDB_ABORT, PSF_CLICKED):
case PEG_SIGNAL(IDB_APPLY, PSF_CLICKED):
Destroy(this);
return(Mesg.iData);
default:
return (PegThing::Message(Mesg));
}
return (Result);
}
/*--------------------------------------------------------------------------*/
SIGNED PegWindow::GlobalModalExecute(void)
{
PegMessage pSend;
PegThing *Current;
mbModal = TRUE;
SIGNED iReturn = 0;
if (CURRENT_TASK != PEG_TASK_PTR)
{
Presentation()->BeginSubTaskExecute(this);
}
CapturePointer();
Presentation()->Add(this);
while(1)
{
MessageQueue()->Pop(&pSend);
switch (pSend.wType)
{
case PM_LBUTTONDOWN:
case PM_RBUTTONDOWN:
case PM_LBUTTONUP:
case PM_RBUTTONUP:
case PM_POINTER_MOVE:
#if defined(PEG_MOUSE_SUPPORT)
if (pSend.wType == PM_POINTER_MOVE)
{
Screen()->SetPointer(pSend.Point);
}
#endif
if (muMoveMode)
{
Message(pSend);
break;
}
if (Presentation()->First() == this)
{
Current = Presentation()->GetPointerOwner();
if (Current != this)
{
// One of my children has captured the pointer,
// let him have the pointer messages:
iReturn = Current->Message(pSend);
}
else
{
if (mReal.Contains(pSend.Point))
{
Current = Presentation()->FindLowestThingContaining(this, pSend.Point);
if (Current)
{
if (Current != Presentation()->LastPointerOver())
{
if (Presentation()->LastPointerOver())
{
Presentation()->LastPointerOver()->Message(PegMessage(PM_POINTER_EXIT));
}
Presentation()->LastPointerOver(Current);
Current->Message(PegMessage(PM_POINTER_ENTER));
}
if ((pSend.wType == PM_LBUTTONDOWN || pSend.wType == PM_RBUTTONDOWN) &&
Current != Presentation()->GetCurrentThing())
{
if (Current->StatusIs(PSF_ACCEPTS_FOCUS))
{
Presentation()->MoveFocusTree(Current);
}
}
iReturn = Current->Message(pSend);
}
}
}
}
else
{
// If we get here, it means another task is modally executing
// a window, and it is now on top. Try to pass mouse messages
// to that task:
if (CURRENT_TASK == PEG_TASK_PTR)
{
Presentation()->RouteMessageToTask(&pSend);
}
}
break;
#ifdef PEG_KEYBOARD_SUPPORT
case PM_KEY:
if (pSend.iData == PK_TAB && (pSend.lData & KF_CTRL))
{
break;
}
// fall throught to the default case:
#endif
default:
iReturn = Presentation()->DispatchMessage(this, &pSend);
break;
}
if (iReturn)
{
Presentation()->EndSubTaskExecute(this);
ReleasePointer();
return(iReturn);
}
}
}
/*--------------------------------------------------------------------------*/
SIGNED PegWindow::Execute(void)
{
PegMessage pSend;
mbModal = TRUE;
SIGNED iReturn;
#ifdef PEG_MULTITHREAD
if (CURRENT_TASK != PEG_TASK_PTR)
{
Presentation()->BeginSubTaskExecute(this);
}
#endif
if (!StatusIs(PSF_VISIBLE))
{
Presentation()->Add(this);
}
while(1)
{
MessageQueue()->Pop(&pSend);
switch (pSend.wType)
{
case PM_LBUTTONDOWN:
case PM_RBUTTONDOWN:
case PM_LBUTTONUP:
case PM_RBUTTONUP:
#ifdef PEG_MULTITHREAD
if (CURRENT_TASK == PEG_TASK_PTR)
{
if (Presentation()->RouteMessageToTask(&pSend))
{
break;
}
}
#endif
if (mReal.Contains(pSend.Point) ||
Presentation()->IsPointerCaptured())
{
//Presentation()->DispatchMessage(this, &pSend);
Presentation()->DispatchMessage(Presentation(), &pSend);
}
break;
case PM_POINTER_MOVE:
#ifdef PEG_MULTITHREAD
if (CURRENT_TASK == PEG_TASK_PTR)
{
if (Presentation()->RouteMessageToTask(&pSend))
{
break;
}
}
#endif
if (mReal.Contains(pSend.Point) ||
Presentation()->IsPointerCaptured())
{
//Presentation()->DispatchMessage(this, &pSend);
Presentation()->DispatchMessage(Presentation(), &pSend);
}
else
{
if (mbShowPointer)
{
SetPointerType(PPT_NORMAL);
mbShowPointer = 0;
}
Screen()->SetPointer(pSend.Point);
}
break;
#ifdef PEGWIN32
// When running under Windows, the user might close the development
// window, without first closing the modal PEG window. There seems to be
// no way to prevent this. In order to terminate correctly, we push
// a couple of PM_EXIT messages, to be sure that all modal windows are
// terminated, and PegPresentationManager returns.
case PM_EXIT:
{
PegMessage NewMessage;
NewMessage.wType = PM_EXIT;
NewMessage.pTarget = Presentation();
NewMessage.pSource = NULL;
MessageQueue()->Push(NewMessage);
MessageQueue()->Push(NewMessage);
return(PM_EXIT);
}
#endif
#ifdef PEG_KEYBOARD_SUPPORT
case PM_KEY:
if (pSend.iData == PK_TAB && (pSend.lData & KF_CTRL))
{
break;
}
// fall throught to the default case:
#endif
default:
#ifdef PEG_MULTITHREAD
if (CURRENT_TASK == PEG_TASK_PTR)
{
if (Presentation()->RouteMessageToTask(&pSend))
{
break;
}
}
#endif
iReturn = Presentation()->DispatchMessage(this, &pSend);
if (iReturn)
{
#ifdef PEG_MULTITHREAD
Presentation()->EndSubTaskExecute(this);
#endif
return(iReturn);
}
}
}
}
void PegMenu::MenuKeyHandler(SIGNED iKey)
{
PegMenuButton *pButton1;
PegMenuButton *pButton = MenuFindActiveButton((PegMenuButton *) First());
if (!pButton)
{
return;
}
switch(iKey)
{
case PK_RIGHT:
if (pButton->IsSubVisible())
{
MenuMoveToButton(pButton, pButton->GetSubMenu()->First());
}
break;
case PK_LEFT:
pButton1 = MenuFindOwnerButton(pButton, (PegMenuButton *) First());
if (pButton1)
{
pButton->Message(PM_POINTER_EXIT);
pButton1->Message(PM_POINTER_ENTER);
pButton1->Message(PM_LBUTTONDOWN);
}
break;
case PK_LNDN:
if (MenuNextButton(pButton))
{
pButton->Message(PM_POINTER_EXIT);
MenuNextButton(pButton)->Message(PM_POINTER_ENTER);
}
break;
case PK_LNUP:
if (MenuPreviousButton(pButton))
{
pButton->Message(PM_POINTER_EXIT);
MenuPreviousButton(pButton)->Message(PM_POINTER_ENTER);
}
break;
case PK_CR:
pButton->Message(PM_LBUTTONDOWN);
break;
case PK_ESC:
pButton->Message(PM_POINTER_EXIT);
Parent()->Remove(this);
if (pButton->GetOwner())
{
Presentation()->MoveFocusTree(pButton->GetOwner());
}
break;
default:
break;
}
}
/*--------------------------------------------------------------------------*/
SIGNED ServiceAudioMenuClass::Message(const PegMessage &Mesg)
{
PegThing *SomeThing;
ServiceMenuClass *pServiceWindow;
switch (Mesg.wType)
{
case SIGNAL(ThrSwNICAMButtonID, PSF_CLICKED):
// Enter your code here:
break;
case SIGNAL(ThrSwNICAMButtonID, PSF_FOCUS_RECEIVED):
// Enter your code here:
break;
case SIGNAL(ThrSwNICAMButtonID, PSF_FOCUS_LOST):
// Enter your code here:
break;
case SIGNAL(PrescNICAMButtonID, PSF_CLICKED):
// Enter your code here:
break;
case SIGNAL(PrescNICAMButtonID, PSF_FOCUS_RECEIVED):
// Enter your code here:
break;
case SIGNAL(PrescNICAMButtonID, PSF_FOCUS_LOST):
// Enter your code here:
break;
case SIGNAL(PrescFMButtonID, PSF_CLICKED):
// Enter your code here:
break;
case SIGNAL(PrescFMButtonID, PSF_FOCUS_RECEIVED):
// Enter your code here:
break;
case SIGNAL(PrescFMButtonID, PSF_FOCUS_LOST):
// Enter your code here:
break;
case SIGNAL(PrescSCARTButtonID, PSF_CLICKED):
// Enter your code here:
break;
case SIGNAL(PrescSCARTButtonID, PSF_FOCUS_RECEIVED):
// Enter your code here:
break;
case SIGNAL(PrescSCARTButtonID, PSF_FOCUS_LOST):
// Enter your code here:
break;
case SIGNAL(AGCAdjButtonID, PSF_CLICKED):
// Enter your code here:
break;
case SIGNAL(AGCAdjButtonID, PSF_FOCUS_RECEIVED):
// Enter your code here:
if(pAGCMessageWindow == NULL)
{
pAGCMessageWindow = new AGCMessageClass(100,50);
Presentation()->Add(pAGCMessageWindow);
}
break;
case SIGNAL(AGCAdjButtonID, PSF_FOCUS_LOST):
// Enter your code here:
if(pAGCMessageWindow != NULL)
{
Destroy(pAGCMessageWindow);
pAGCMessageWindow = NULL;
}
break;
case PM_KEYLEFT:
case PM_KEYRIGHT:
switch(Mesg.iData)
{
case ThrSwNICAMButtonID:
if(Mesg.wType == PM_KEYRIGHT)
{
if (pThrSwNICAMBar->Value() < pThrSwNICAMBar->GetMaxValue())
{
pThrSwNICAMBar->Update(pThrSwNICAMBar->Value()+1,TRUE);
}
}
else /* PM_KEYLEFT */
{
if (pThrSwNICAMBar->Value() > pThrSwNICAMBar->GetMinValue())
{
pThrSwNICAMBar->Update(pThrSwNICAMBar->Value()-1,TRUE);
}
}
break;
case PrescNICAMButtonID:
if(Mesg.wType == PM_KEYRIGHT)
{
if (pPrescNICAMBar->Value() < pPrescNICAMBar->GetMaxValue())
{
pPrescNICAMBar->Update(pPrescNICAMBar->Value()+1,TRUE);
}
}
else /* PM_KEYLEFT */
{
if (pPrescNICAMBar->Value() > pPrescNICAMBar->GetMinValue())
{
pPrescNICAMBar->Update(pPrescNICAMBar->Value()-1,TRUE);
}
}
break;
case PrescFMButtonID:
if(Mesg.wType == PM_KEYRIGHT)
{
if (pPrescFMBar->Value() < pPrescFMBar->GetMaxValue())
{
pPrescFMBar->Update(pPrescFMBar->Value()+1,TRUE);
}
}
else /* PM_KEYLEFT */
{
if (pPrescFMBar->Value() > pPrescFMBar->GetMinValue())
{
pPrescFMBar->Update(pPrescFMBar->Value()-1,TRUE);
}
}
break;
case PrescSCARTButtonID:
if(Mesg.wType == PM_KEYRIGHT)
{
if (pPrescSCARTBar->Value() < pPrescSCARTBar->GetMaxValue())
{
pPrescSCARTBar->Update(pPrescSCARTBar->Value()+1,TRUE);
}
}
else /* PM_KEYLEFT */
{
if (pPrescSCARTBar->Value() > pPrescSCARTBar->GetMinValue())
{
pPrescSCARTBar->Update(pPrescSCARTBar->Value()-1,TRUE);
}
}
break;
case AGCAdjButtonID:
if(Mesg.wType == PM_KEYRIGHT)
{
if (pAGCAdjBar->Value() < pAGCAdjBar->GetMaxValue())
{
pAGCAdjBar->Update(pAGCAdjBar->Value()+1,TRUE);
}
}
else /* PM_KEYLEFT */
{
if (pAGCAdjBar->Value() > pAGCAdjBar->GetMinValue())
{
pAGCAdjBar->Update(pAGCAdjBar->Value()-1,TRUE);
}
}
break;
}
break;
case PM_REFRESHWINDOW:
unsigned char ucCurrentValue;
pAGCAdjBar->Update(ucCurrentValue,TRUE);
if(ucCurrentValue == 0)
{
/* Get the pointer to the LOW AGC Message Window */
SomeThing = PegThing::Presentation()->Find(LOWAGC_MESSAGE_ID);
if(SomeThing)
{
Destroy(SomeThing);
}
PopupWindowClass *pPopupWindow;
char *LowAGCMessage = "Low Signal Strength";
PEGCHAR PegTable[20]; /* 15 char max to 20*/
PEGCHAR* pPegText;
DisplayedString_t sStringToDisplay;
char* pText;
unsigned char iLoop;
PegThing::Presentation()->BeginDraw();
pText= LowAGCMessage;
pPegText = PegTable;
for (iLoop = 0 ; iLoop<20 ; iLoop++) /* 15 to 20 */
*pPegText++ = *pText++;
sStringToDisplay.ucTableSize = 1; /* one string to display */
sStringToDisplay.pTextString1 = PegTable;
/* now display message */
pPopupWindow = new PopupWindowClass(50, 50, 200, 50, NULL, kCenterBitmap , PegBlueTransparent, FF_NONE, &sStringToDisplay, BLUE, PopupTimout, LOWAGC_MESSAGE_ID);
PegThing::Presentation()->Add(pPopupWindow);
PegThing::Presentation()->EndDraw();
}
break;
case PM_CLOSE:
if(pAGCMessageWindow != NULL)
{
Destroy(pAGCMessageWindow);
pAGCMessageWindow = NULL;
}
Destroy(this);
pServiceWindow = (ServiceMenuClass*) Presentation()->Find(SERVICE_MENU_ID);
pServiceWindow->SetBackgroundColor(PegBlueTransparent);
break;
default:
return PegWindow::Message(Mesg);
}
return 0;
}
/*--------------------------------------------------------------------------*/
SIGNED PicturePlusMenuClass::Message(const PegMessage &Mesg)
{
ScreenMenuClass *pPictureWindow;
BOOL bValueChanged = FALSE;
switch (Mesg.wType)
{
case PM_KEYLEFT:
case PM_KEYRIGHT:
switch(Mesg.iData)
{
case TintButtonID:
/* use uPictureValueToUpdate temporary union in case we want to display
a small bar alone for tint tuning (see Picture->Contrast, Brightness Sharpness or Color, Video or Geometry menu)*/
if (Mesg.wType == PM_KEYLEFT)
{
if (pTintBar->Value() > pTintBar->GetMinValue())
{
pTintBar->Update(pTintBar->Value()-1,TRUE);
bValueChanged = TRUE;
}
}
else if (Mesg.wType == PM_KEYRIGHT)
{
if (pTintBar->Value() < pTintBar->GetMaxValue())
{
pTintBar->Update(pTintBar->Value()+1,TRUE);
bValueChanged = TRUE;
}
}
if (bValueChanged)
{
bValueChanged = FALSE;
}
break;
case RotationButtonID:
/* use uPictureValueToUpdate temporary union in case we want to display
a small bar alone for tint tuning (see Picture->Contrast, Brightness Sharpness or Color, Video or Geometry menu)*/
if (Mesg.wType == PM_KEYLEFT)
{
if (pRotationBar->Value() > pRotationBar->GetMinValue())
{
pRotationBar->Update(pRotationBar->Value()-1,TRUE);
bValueChanged = TRUE;
}
}
else if (Mesg.wType == PM_KEYRIGHT)
{
if (pRotationBar->Value() < pRotationBar->GetMaxValue())
{
pRotationBar->Update(pRotationBar->Value()+1,TRUE);
bValueChanged = TRUE;
}
}
if (bValueChanged)
{
bValueChanged = FALSE;
}
break;
case NRButtonID:
break;
case DigitalScanButtonID:
break;
case CTIButtonID:
break;
case GreenBoostButtonID:
break;
case ChromaCoringButtonID:
break;
case CombFilterButtonID:
break;
case ContrastEnhButtonID:
break;
case AutoFleshButtonID:
break;
case IfpLevelButtonID:
break;
}
break;
case PM_REFRESHWINDOW:
RefreshPicturePlusWindow();
break;
case PM_CLOSE:
/* left key = close = go back to previous menu */
Destroy(this);
pPictureWindow = (ScreenMenuClass*) Presentation()->Find(PICTURE_MENU_ID);
pPictureWindow->SetBitmap(&gbPictBitmap);
break;
default:
return PegWindow::Message(Mesg);
}
return 0;
}
/*--------------------------------------------------------------------------*/
void PegMenuBar::MenuKeyHandler(SIGNED iKey)
{
PegMenuButton *pButton = MenuFindActiveButton((PegMenuButton *) First());
PegMenuButton *pButton1;
if (iKey == PK_MENU_KEY)
{
if (First())
{
if (pButton)
{
pButton->Message(PM_POINTER_EXIT);
}
Presentation()->MoveFocusTree(this);
First()->Message(PM_POINTER_ENTER);
}
return;
}
if (!pButton)
{
return;
}
switch(iKey)
{
case PK_RIGHT:
if (pButton->Parent() == this)
{
if (MenuNextButton(pButton))
{
MenuMoveToButton(pButton, MenuNextButton(pButton));
}
}
else
{
if (pButton->IsSubVisible())
{
MenuMoveToButton(pButton, pButton->GetSubMenu()->First());
}
else
{
pButton1 = MenuFindOwnerButton(pButton,
(PegMenuButton *) First());
while(pButton1 && !MenuNextButton(pButton1))
{
pButton1 = MenuFindOwnerButton(pButton1,
(PegMenuButton *) First());
}
if (pButton1)
{
MenuMoveToButton(pButton, MenuNextButton(pButton1));
}
}
}
break;
case PK_LNDN:
if (MenuNextButton(pButton))
{
pButton->Message(PM_POINTER_EXIT);
MenuNextButton(pButton)->Message(PM_POINTER_ENTER);
}
break;
case PK_LEFT:
if (pButton->Parent() == this)
{
if (MenuPreviousButton(pButton))
{
MenuMoveToButton(pButton, MenuPreviousButton(pButton));
}
}
else
{
pButton1 = MenuFindOwnerButton(pButton, (PegMenuButton *) First());
if (pButton1)
{
pButton->Message(PM_POINTER_EXIT);
pButton1->Message(PM_POINTER_ENTER);
if (pButton1->Parent() == this && MenuPreviousButton(pButton1))
{
MenuMoveToButton(pButton1, MenuPreviousButton(pButton1));
}
else
{
pButton1->Message(PM_LBUTTONDOWN);
}
}
}
break;
case PK_LNUP:
if (MenuPreviousButton(pButton))
{
pButton->Message(PM_POINTER_EXIT);
MenuPreviousButton(pButton)->Message(PM_POINTER_ENTER);
}
break;
case PK_CR:
pButton->Message(PM_LBUTTONDOWN);
if (pButton->Parent() == this && pButton->mbSubVisible)
{
pButton->Message(PM_POINTER_EXIT);
pButton->mpSubMenu->First()->Message(PM_POINTER_ENTER);
}
break;
case PK_ESC:
pButton->Message(PM_POINTER_EXIT);
Presentation()->MoveFocusTree(Parent());
break;
default:
break;
}
}
void MainMenu::DisplayChildWindow(int iSubWndID)
{
if(ID_MainMenu_Button_FactorySetting > iSubWndID || ID_MainMenu_Button_SupFunction < iSubWndID)
{
return;
}
m_nCurrentSubWndID = iSubWndID;
SIGNED nTipLeftTopY = mReal.wTop + m_nCurrentSubWndID * 50;
PictureMenu * pPictureMenu = NULL;
SoundMenu * pSoundMenu = NULL;
SupSettingMenu * pSuperSettingMenu = NULL;
SuperFuction * pSuperFunctionMenu = NULL;
FactoryMenu * pFactoryMenu = NULL;
switch(iSubWndID)
{
case ID_MainMenu_Buttion_Picture:
{
pPictureMenu = new PictureMenu(mReal.wRight, nTipLeftTopY);
Presentation()->Add(pPictureMenu);
pPictureMenu->SetTVHelpWnd(m_pTVHelpWnd);
pPictureMenu->SetToolTipWnd(m_pToolTip);
pPictureMenu->ProcessUpDownKey();
break;
}
case ID_MainMenu_Button_Sound:
{
pSoundMenu = new SoundMenu(mReal.wRight, nTipLeftTopY);
Presentation()->Add(pSoundMenu);
pSoundMenu->SetTVHelpWnd(m_pTVHelpWnd);
pSoundMenu->SetToolTipWnd(m_pToolTip);
pSoundMenu->ProcessUpDownKey();
break;
}
case ID_MainMenu_Button_SupSetting:
{
pSuperSettingMenu = new SupSettingMenu(mReal.wRight, nTipLeftTopY);
Presentation()->Add(pSuperSettingMenu);
pSuperSettingMenu->SetTVHelpWnd(m_pTVHelpWnd);
pSuperSettingMenu->SetToolTipWnd(m_pToolTip);
pSuperSettingMenu->ProcessUpDownKey();
break;
}
case ID_MainMenu_Button_SupFunction:
{
pSuperFunctionMenu = new SuperFuction(mReal.wRight, nTipLeftTopY);
Presentation()->Add(pSuperFunctionMenu);
pSuperFunctionMenu->SetTVHelpWnd(m_pTVHelpWnd);
pSuperFunctionMenu->SetToolTipWnd(m_pToolTip);
pSuperFunctionMenu->ProcessUpDownKey();
break;
}
case ID_MainMenu_Button_FactorySetting:
{
pFactoryMenu = new FactoryMenu(mReal.wRight, nTipLeftTopY);
Presentation()->Add(pFactoryMenu);
pFactoryMenu->SetTVHelpWnd(m_pTVHelpWnd);
pFactoryMenu->SetToolTipWnd(m_pToolTip);
pFactoryMenu->ProcessUpDownKey();
break;
}
default:
{
break;
}
}
}
/*--------------------------------------------------------------------------*/
SIGNED MainMenu::Message(const PegMessage &Mesg)
{
switch (Mesg.wType)
{
case SIGNAL(ID_MainMenu_Button_FactorySetting, PSF_CLICKED):
// Enter your code here:
break;
case SIGNAL(ID_MainMenu_Button_SupFunction, PSF_CLICKED):
// Enter your code here:
break;
case SIGNAL(ID_MainMenu_Button_SupSetting, PSF_CLICKED):
// Enter your code here:
break;
case SIGNAL(ID_MainMenu_Button_Sound, PSF_CLICKED):
// Enter your code here:
break;
case SIGNAL(ID_MainMenu_Buttion_Picture, PSF_CLICKED):
// Enter your code here:
break;
case PM_KEYRIGHT:
{
DisplayChildWindow(Mesg.iData);
break;
}
case PM_KEYUP:
{
m_nCurrentSubWndID = Mesg.iData;
if( ID_MainMenu_Button_FactorySetting < m_nCurrentSubWndID)
{
m_nCurrentSubWndID--;
}
else
{
m_nCurrentSubWndID = (int)ID_MainMenu_Button_SupFunction;
Presentation()->MoveFocusTree(m_pMainMenuButton_SupFunction);
}
ProcessUpDownKey();
break;
}
case PM_KEYDOWN:
{
m_nCurrentSubWndID = Mesg.iData;
if( ID_MainMenu_Button_SupFunction > m_nCurrentSubWndID)
{
m_nCurrentSubWndID++;
}
else
{
m_nCurrentSubWndID = (int)ID_MainMenu_Button_FactorySetting;
Presentation()->MoveFocusTree(m_pMainMenuButtonFactorySetting);
}
ProcessUpDownKey();
break;
}
default:
return PegWindow::Message(Mesg);
}
return 0;
}
/*--------------------------------------------------------------------------*/
SIGNED PictureMenu::Message(const PegMessage &Mesg)
{
TVProgressWindowClass * pTVProgressWindow = NULL;
PegThing *ptDisplayedWindow[MaxNumberOfWindow];
PegThing *SomeThing = NULL;
PegThing *pTest;
int iIndex;
switch (Mesg.wType)
{
case SIGNAL(ID_PictureMenu_Button_ColorTemp, PSF_CLICKED):
// Enter your code here:
break;
case SIGNAL(ID_PictureMenu_Button_Color, PSF_CLICKED):
// Enter your code here:
break;
case SIGNAL(ID_PictureMenu_Button_Sharp, PSF_CLICKED):
// Enter your code here:
break;
case SIGNAL(ID_PictureMenu_Button_Tint, PSF_CLICKED):
// Enter your code here:
break;
case SIGNAL(ID_PictureMenu_Button_Contrast, PSF_CLICKED):
// Enter your code here:
break;
case SIGNAL(ID_PictureMenu_Button_Brightness, PSF_CLICKED):
// Enter your code here:
break;
case PM_KEYUP:
{
m_nCurrentSubWndID = Mesg.iData;
if(ID_PictureMenu_Button_Brightness > m_nCurrentSubWndID)
{
m_nCurrentSubWndID++;
}
else
{
m_nCurrentSubWndID = (int)ID_PictureMenu_Button_ColorTemp;
Presentation()->MoveFocusTree(m_pPictureMenuButtonColorTemp);
}
ProcessUpDownKey();
break;
}
case PM_KEYDOWN:
{
m_nCurrentSubWndID = Mesg.iData;
if(ID_PictureMenu_Button_ColorTemp < m_nCurrentSubWndID)
{
m_nCurrentSubWndID--;
}
else
{
m_nCurrentSubWndID = (int)ID_PictureMenu_Button_Brightness;
Presentation()->MoveFocusTree(m_pPictuerMenuButtonBright);
}
ProcessUpDownKey();
break;
}
case PM_KEYLEFT:
{
Destroy(this);
MainMenu * pMainMenu = (MainMenu *)Presentation()->Find(MAIN_MENU_ID);
pMainMenu->ProcessUpDownKey();
break;
}
case PM_KEYRIGHT:
{
if(ID_PictureMenu_Button_ColorTemp == Mesg.iData || \
ID_PictureMenu_Button_Color == Mesg.iData || \
ID_PictureMenu_Button_Tint == Mesg.iData || \
ID_PictureMenu_Button_Contrast == Mesg.iData || \
ID_PictureMenu_Button_Sharp == Mesg.iData || \
ID_PictureMenu_Button_Brightness == Mesg.iData)
{
/* right key equals OK, so enter next menu level */
BeginDraw();
/* Delete all pop up already displayed to clean the screen */
for(iIndex = FIRST_POPUP_ID; iIndex < LAST_USER_ID; iIndex++)
{
SomeThing = PegThing::Presentation()->Find(iIndex);
if(SomeThing!=NULL)
{
PegThing::Presentation()->Destroy(SomeThing);
}
}
/*hide all the menus displayed on screen except the help window*/
pTest = PegPresentationManager::Presentation()->First();
iIndex = 0;
while(pTest) /* construct the current displayed window pointer table */
{
if(HELP_ID == pTest->Id())
{
pTest = PegPresentationManager::Presentation()->Next();
continue;
}
else
{
ptDisplayedWindow[iIndex++] = pTest;
PegPresentationManager::Presentation()->Remove(pTest);
pTest = PegPresentationManager::Presentation()->First();
}
}
ptDisplayedWindow[iIndex] = NULL; /* reset last pointer */
switch(Mesg.iData)
{
case ID_PictureMenu_Button_Brightness:
{
pTVProgressWindow = new TVProgressWindowClass(100, 400, m_pPictuerMenuButtonBright, \
Ssb_BrightnessChange, kPegMenuPicture, \
LS(SID_PictureMenu_Prompt_Brightness), RED, FF_RAISED | PS_SHOW_VAL, 0, \
100, 30, ptDisplayedWindow);
Presentation()->Add(pTVProgressWindow);
m_pTVHelpWnd->ShowHelpString(LS(SID_PictureMenu_Prompt_Brightness), NEWMENU_BAR_TYPE);
break;
}
case ID_PictureMenu_Button_Contrast:
{
pTVProgressWindow = new TVProgressWindowClass(100, 400, m_pPictureMenuButtonContrast, \
Ssb_ContrastChange, kPegMenuPicture, \
LS(SID_PictureMenu_Prompt_Contrast), RED, FF_RAISED|PS_SHOW_VAL, 0, \
100, 30, ptDisplayedWindow);
Presentation()->Add(pTVProgressWindow);
m_pTVHelpWnd->ShowHelpString(LS(SID_PictureMenu_Prompt_Contrast), NEWMENU_BAR_TYPE);
break;
}
case ID_PictureMenu_Button_Tint:
{
pTVProgressWindow = new TVProgressWindowClass(100, 400, m_pPictureMenuButtonTint, \
Ssb_TintChange, kPegMenuPicture, \
LS(SID_PictureMenu_Prompt_Tint), RED, FF_RAISED|PS_SHOW_VAL, 0, \
100, 30, ptDisplayedWindow);
Presentation()->Add(pTVProgressWindow);
m_pTVHelpWnd->ShowHelpString(LS(SID_PictureMenu_Prompt_Tint), NEWMENU_BAR_TYPE);
break;
}
case ID_PictureMenu_Button_ColorTemp:
{
pTVProgressWindow = new TVProgressWindowClass(100, 400, m_pPictureMenuButtonColorTemp, \
Ssb_ColorTemperatureChange, kPegMenuPicture, \
LS(SID_PictureMenu_Prompt_ColorTemp), RED, FF_RAISED|PS_SHOW_VAL, 0, \
100, 30, ptDisplayedWindow);
Presentation()->Add(pTVProgressWindow);
m_pTVHelpWnd->ShowHelpString(LS(SID_PictureMenu_Prompt_ColorTemp), NEWMENU_BAR_TYPE);
break;
}
case ID_PictureMenu_Button_Color:
{
pTVProgressWindow = new TVProgressWindowClass(100, 400, m_pPictureMenuButtonColor, \
Ssb_ColorChange, kPegMenuPicture, \
LS(SID_PictureMenu_Prompt_Color), RED, FF_RAISED|PS_SHOW_VAL, 0, \
100, 20, ptDisplayedWindow);
Presentation()->Add(pTVProgressWindow);
m_pTVHelpWnd->ShowHelpString(LS(SID_PictureMenu_Prompt_Color), NEWMENU_BAR_TYPE);
break;
}
case ID_PictureMenu_Button_Sharp:
{
pTVProgressWindow = new TVProgressWindowClass(100, 400, m_pPictureMenuButtonSharp, \
Ssb_SharpnessChange, kPegMenuPicture, \
LS(SID_PictureMenu_Prompt_Sharpness), RED, FF_RAISED|PS_SHOW_VAL, 0, \
100, 20, ptDisplayedWindow);
Presentation()->Add(pTVProgressWindow);
m_pTVHelpWnd->ShowHelpString(LS(SID_PictureMenu_Prompt_Sharpness), NEWMENU_BAR_TYPE);
break;
}
default:
break;
}
EndDraw();
}
break;
}
case PM_REFRESHHELPWND:
{
ProcessUpDownKey();
break;
}
default:
return PegWindow::Message(Mesg);
}
return 0;
}
/////////////////////////////////////////////////////////////////////////////
//#include <pmessage.hpp>
SIGNED MyMainFrame::Message(const PegMessage &msg)
{
bool ok;
switch(msg.wType)
{
//case PM_ADD:
// addWindow( (PegWindow*)msg.pSource );
// break;
case PM_DRAW:
Invalidate();
Draw();
break;
case HM_SYS_KEYBOARD:
toggleKeypad();
break;
//case HM_SYS_RESUME:
// break;
case HM_SYS_ZOOM:
if(m_allowResizeKey) setFullScreenApp(!m_fullScreen);
break;
case HM_SYS_CLEAR:
if(m_activeWin && m_activeWin->onClearKeyPressed())
removeWindow(m_activeWin);
break;
case PM_FIRST_START:
if(m_activeWin) Presentation()->MoveFocusTree(m_activeWin);
break;
case SIGNAL(DEF_MENU_QUIT, PSF_CLICKED):
programQuit();
break;
case MYMF_SEND_SIGNAL:
((MyWindow*)msg.pSource)->onSignal(msg.iData);
break;
default:
ok = false;
if(m_activeWin) m_otherWin.Insert(m_activeWin);
ent ptr2;
CPListIterator it2(&m_otherWin);
for(ptr2 = it2.Head(); ptr2!=NULL; ptr2 = it2.Next())
{
ent ptr;
CPListIterator it( ((MyWindow*)ptr2)->handledSignalsList() );
for(ptr = it.Head(); ptr!=NULL; ptr = it.Next())
{
if( msg.wType == *((WORD*)ptr) )
{
prepareSignal((MyWindow*)ptr2, msg.wType);
ok=true;
break;
}
}
}
m_otherWin.Remove(m_activeWin);
if(!ok) return PegWindow::Message(msg);
}
return 0;
}
