/*--------------------------------------------------------------------------*/ 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; }