void CHeaderView::PreSubClassWnd()
{
m_pParentWnd = GetParent();
ASSERT(m_pParentWnd);
ClearImages();
ReDraw();
}
//********************************************************************
void CGuiHeaderCtrl::PreSubclassWindow()
{
m_pParentWnd = GetParent();
ASSERT(m_pParentWnd);
CHeaderCtrl::PreSubclassWindow();
ClearImages();
ReDraw();
}
//*********************************************************************
void CHeaderView::OnWindowPosChanged(WINDOWPOS FAR* lpwndpos)
{
Default();
Invalidate();
UpdateWindow();
ReDraw();
}
//*********************************************************************
void CGuiHeaderCtrl::OnWindowPosChanged(WINDOWPOS FAR* lpwndpos)
{
CHeaderCtrl::OnWindowPosChanged(lpwndpos);
Invalidate();
UpdateWindow();
ReDraw();
}
void __fastcall TCallCenter_Sub_Form::Timer1Timer(TObject *Sender)
{
//假如Terminate,將Timer停掉
if(Application->Terminated)
{
Timer1->Enabled = false;
return;
}
ReDraw();
}
void EDA_DRAW_PANEL::OnPaint( wxPaintEvent& event )
{
if( GetScreen() == NULL )
{
event.Skip();
return;
}
INSTALL_PAINTDC( paintDC, this );
wxRect region = GetUpdateRegion().GetBox();
SetClipBox( paintDC, ®ion );
ReDraw( &paintDC, true );
}
Acad::ErrorStatus CGraphListCtrl::InsertItem( int nItem, CGraphBlockViewWnd* pItem, LPCTSTR szTitleName, DWORD dwData )
{
pItem->SetName(szTitleName);
pItem->SetData(dwData);
if(nItem >= GetItemCount())
{
m_arrayItem.Add(pItem);
}
else
{
m_arrayItem.InsertAt(nItem, pItem);
}
ReDraw();
return Acad::eOk;
}
//---------------------------------------------------------------------------
void __fastcall TCallCenter_Sub_Form::FormShow(TObject *Sender)
{
if( m_pCar==NULL )
return;
ReDraw();
//Image Status
if(m_pImage_Car->Tag != m_pCar->m_pImage_Car->Tag) //Change Car Image
{
m_pImage_Car->Tag = m_pCar->m_pImage_Car->Tag;
CallCenter_Main_Form->ChangeCarImgByTag(m_pImage_Car,1);
m_pImage_Car->Left = (Image_Map_Sub->Left) + (Image_Map_Sub->ClientWidth/2 - m_pImage_Car->Width/2);
m_pImage_Car->Top = (Image_Map_Sub->Top) + (Image_Map_Sub->ClientHeight/2 - m_pImage_Car->Height/2);
}
Image_Map_Sub->ShowHint = true;
Image_Map_Sub->Hint = AnsiString("追蹤監控視窗\n車號: ")+AnsiString(m_pCar->GetCarID());;
}
void WinEDA_DrawPanel::OnPaint(wxPaintEvent & event)
/***************************************************/
{
wxPaintDC paintDC(this);
EDA_Rect tmp;
wxRect PaintClipBox;
wxPoint org;
PrepareGraphicContext(&paintDC);
tmp = m_ClipBox;
org = m_ClipBox.GetOrigin();
wxRegionIterator upd(GetUpdateRegion()); // get the update rect list
while ( upd )
{
PaintClipBox = upd.GetRect();
upd++;
PaintClipBox.x += org.x;
PaintClipBox.y += org.y;
#ifdef WX_ZOOM
m_ClipBox.m_Pos.x = PaintClipBox.x * GetZoom();
m_ClipBox.m_Pos.y = PaintClipBox.y * GetZoom();
m_ClipBox.m_Size.x = PaintClipBox.m_Size.x * GetZoom();
m_ClipBox.m_Size.y = PaintClipBox.m_Size.y * GetZoom();
PaintClipBox = m_ClipBox;
#else
m_ClipBox.SetX(PaintClipBox.GetX());
m_ClipBox.SetY(PaintClipBox.GetY());
m_ClipBox.SetWidth(PaintClipBox.GetWidth());
m_ClipBox.SetHeight(PaintClipBox.GetHeight());
#endif
wxDCClipper * dcclip = new wxDCClipper(paintDC, PaintClipBox);
ReDraw(&paintDC, TRUE);
delete dcclip;
}
m_ClipBox = tmp;
}
int main (int argc, char *argv[])
{
Uint8* mouse;
bool start=false;
bool exitstate=false;
int clickx,clicky;
ClearField();
if(SDL_Init(SDL_INIT_VIDEO)<0)
{
printf("Unable to init SDL: %s\n",SDL_GetError());
exit(1);
}
atexit(SDL_Quit);
SDL_WM_SetCaption("Life game","life");
screen=SDL_SetVideoMode(640,480,32,SDL_HWSURFACE|SDL_DOUBLEBUF);
if(screen==NULL)
{
printf("unable to set 640x480 video %s\n",SDL_GetError());
exit(1);
}
InitImages();
DrawIMG(background,0,0);
while(exitstate==false)
{
SDL_Event event;
while(SDL_PollEvent(&event))
{
if(event.type==SDL_QUIT)
{
exitstate=true;
}
if(event.type==SDL_KEYDOWN)
{
if(event.key.keysym.sym=SDLK_ESCAPE)
{
exitstate=true;
}
}
if(event.type==SDL_MOUSEBUTTONUP)
{
clickx=event.button.x;
clicky=event.button.y;
if(clicky>450 && clickx<320)
{
if(start==false)
{
start=true;
}
else
{
start=false;
}
}
if(clicky>450 && clickx>320)
{
ClearField();
start=false;
}
if(clicky<450 && start==false)
{
SetPoint(clickx,clicky);
}
}
}
if(start==true)
{
SDL_Delay(500);
NextGen();
}
ReDraw();
}
return 0;
}
void __fastcall TCallCenter_Sub_Form::ReDraw_SubFormClick(TObject *Sender)
{
ReDraw();
}
//---------------------------------------------------------------------------
void __fastcall TCallCenter_Sub_Form::FormResize(TObject *Sender)
{
ReDraw();
m_pImage_Car->Left = (Image_Map_Sub->Left) + (Image_Map_Sub->ClientWidth/2 - m_pImage_Car->Width/2);
m_pImage_Car->Top = (Image_Map_Sub->Top) + (Image_Map_Sub->ClientHeight/2 - m_pImage_Car->Height/2);
}
void MriWatcherGUI::resizeEvent(QResizeEvent *e)
{
ReDraw();
}
//********************************************************************
int CHeaderView::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
ClearImages();
ReDraw();
return 0;
}
bool MriWatcherGUI::eventFilter(QObject* o, QEvent* e)
{
switch( e->type() )
{
case QEvent::FileOpen:
LoadFile(static_cast<QFileOpenEvent *>(e)->file());
break;
case QEvent::KeyPress:
if( static_cast<QKeyEvent *>( e )->key() == Qt::Key_Right )
{
// printf("enter key right\n");
for( int i = m_imageframelist.size() - 2; i >= 0; i-- )
{
if( m_imageframelist[i]->IsSelected() )
{
ImageFrameGUI* m_image = m_imageframelist[i];
m_imageframelist[i] = m_imageframelist[i + 1];
m_imageframelist[i + 1] = m_image;
m_imageframelayout->swap(i, i + 1);
// printf("Call eventFilter of keypress m_frame->height() = %d, m_frame->width()=%d \n", m_frame->height(), m_frame->width());
m_imageframelayout->doLayout(QRect(m_frame->x(), m_frame->y(), m_frame->minimumHeight(), m_frame->minimumWidth() ), false);
}
}
}
if( static_cast<QKeyEvent *>( e )->key() == Qt::Key_Left )
{
// printf("enter key left\n");
for( unsigned int i = 1; i < m_imageframelist.size(); i++ )
{
if( m_imageframelist[i]->IsSelected() )
{
ImageFrameGUI* m_image = m_imageframelist[i];
m_imageframelist[i] = m_imageframelist[i - 1];
m_imageframelist[i - 1] = m_image;
m_imageframelayout->swap(i - 1, i);
// printf("call eventFilter key left m_frame->height() = %d, m_frame->width()=%d \n", m_frame->height(), m_frame->width());
m_imageframelayout->doLayout(QRect(m_frame->x(), m_frame->y(), m_frame->minimumHeight(), m_frame->minimumWidth() ), false);
}
}
}
if( static_cast<QKeyEvent *>( e )->key() == Qt::Key_Delete )
{
// printf("enter key delete\n");
for( unsigned int i = 0; i < m_imageframelist.size(); i++ )
{
if( m_imageframelist[i]->IsSelected() )
{
std::vector<ImageFrameGUI *>::iterator it = m_imageframelist.begin();
for( unsigned int k = 0; k < i; k++ )
{
++it;
}
m_imagemanager.DelWindow2D(m_imageframelist[i]->g_imageframe);
m_imageframelist.erase(it);
m_imageframelayout->deleteItem(i);
m_maxsize[0] = 0;
m_maxsize[1] = 0;
m_maxsize[2] = 0;
for( unsigned int j = 0; j < m_imageframelist.size(); j++ )
{
QtWindow2DFloat::SizeType m_size = m_imageframelist[j]->g_imageframe->GetImageSize();
if( m_size[0] > m_maxsize[0] )
{
m_maxsize[0] = m_size[0];
}
if( m_size[1] > m_maxsize[1] )
{
m_maxsize[1] = m_size[1];
}
if( m_size[2] > m_maxsize[2] )
{
m_maxsize[2] = m_size[2];
}
}
i--;
m_numberofimages--;
ReDraw();
// printf("call eventFilter key delete m_frame->height() = %d, m_frame->width()=%d \n", m_frame->height(), m_frame->width());
m_imageframelayout->doLayout(QRect(m_frame->x(), m_frame->y(), m_frame->minimumHeight(), m_frame->minimumWidth() ), false);
}
}
}
if( static_cast<QKeyEvent *>( e )->matches(QKeySequence::SelectAll) )
{
// printf("enter key select all\n");
for( unsigned int i = 0; i < m_imageframelist.size(); i++ )
{
m_imageframelist[i]->Select();
}
}
if( static_cast<QKeyEvent *>( e )->key() == Qt::Key_O )
{
QString filename = QFileDialog::getOpenFileName(
this,
tr("Select one image files to open"),
QDir::currentPath(),
tr("*.jpg *.gipl* *.raw* *.hdr *.mha *.mhd* *.nhdr* *nrrd* *nii*") );
if( filename != NULL )
{
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName( filename.toLatin1().constData() );
try
{
reader->Update();
}
catch( itk::ExceptionObject & e )
{
QMessageBox::information( this, "MriWatcher", "Unable to load file:\n" + filename.toLatin1() );
return false;
}
m_originalimage = reader->GetOutput();
if( m_originalimage.IsNotNull() )
{
for( unsigned int i = 0; i < m_imageframelist.size(); i++ )
{
if( m_imageframelist[i]->IsSelected() )
{
m_imageframelist[i]->g_imageframe->SetInputOverlay(m_originalimage);
}
}
}
}
}
if( static_cast<QKeyEvent *>( e )->key() == Qt::Key_H )
{
for( unsigned int i = 0; i < m_imageframelist.size(); i++ )
{
if( m_imageframelist[i]->IsSelected() )
{
if( m_imageframelist[i]->g_imageframe->OverlayVisible() )
{
m_imageframelist[i]->g_imageframe->HideOverlay();
}
else
{
m_imageframelist[i]->g_imageframe->ShowOverlay();
}
}
}
}
if( static_cast<QKeyEvent *>( e )->key() == Qt::Key_C )
{
for( unsigned int i = 0; i < m_imageframelist.size(); i++ )
{
if( m_imageframelist[i]->IsSelected() )
{
if( m_imageframelist[i]->g_imageframe->IsCrosshairVisible() )
{
m_imageframelist[i]->g_imageframe->SetCrosshairVisible(false);
}
else
{
m_imageframelist[i]->g_imageframe->SetCrosshairVisible(true);
}
}
}
}
if( static_cast<QKeyEvent *>( e )->key() == Qt::Key_S )
{
QString filename = QFileDialog::getOpenFileName(
this,
tr("Select one image files to open"),
QDir::currentPath(),
tr("*.jpg *.gipl* *.raw* *.hdr *.mha *.mhd* *.nhdr* *nrrd* *nii*") );
if( filename != NULL )
{
ReaderType::Pointer reader = ReaderType::New();
reader->SetFileName( filename.toLatin1().constData() );
try
{
reader->Update();
}
catch( itk::ExceptionObject & e )
{
QMessageBox::information( this, "MriWatcher", "Unable to load file:\n" + filename.toLatin1() );
return false;
}
m_originalimage = reader->GetOutput();
if( m_originalimage.IsNotNull() )
{
for( unsigned int i = 0; i < m_imageframelist.size(); i++ )
{
if( m_imageframelist[i]->IsSelected() )
{
m_imageframelist[i]->g_imageframe->SetInputImage2(m_originalimage);
}
}
}
}
}
if( static_cast<QKeyEvent *>( e )->key() == Qt::Key_Plus )
{
for( unsigned int i = 0; i < m_imageframelist.size(); i++ )
{
if( m_imageframelist[i]->IsSelected() )
{
if( m_imageframelist[i]->g_imageframe->cOverlayOpacity * 100 < 95 )
{
m_imageframelist[i]->g_imageframe->ChangeLabelOverlay( (int)(m_imageframelist[i]->g_imageframe->
cOverlayOpacity * 100 + 5) );
}
}
}
}
if( static_cast<QKeyEvent *>( e )->key() == Qt::Key_Minus )
{
for( unsigned int i = 0; i < m_imageframelist.size(); i++ )
{
if( m_imageframelist[i]->IsSelected() )
{
if( m_imageframelist[i]->g_imageframe->cOverlayOpacity * 100 > 5 )
{
m_imageframelist[i]->g_imageframe->ChangeLabelOverlay( (int)(m_imageframelist[i]->g_imageframe->
cOverlayOpacity * 100 - 5) );
}
}
}
}
if( static_cast<QKeyEvent *>( e )->key() == Qt::Key_Alt )
{
m_keyalt = true;
}
if( static_cast<QKeyEvent *>( e )->key() == Qt::Key_Control )
{
m_keyctrl = true;
}
break;
case QEvent::KeyRelease:
if( static_cast<QKeyEvent *>( e )->key() == Qt::Key_Alt )
{
m_keyalt = false;
}
if( static_cast<QKeyEvent *>( e )->key() == Qt::Key_Control )
{
m_keyctrl = false;
}
break;
default: break;
}
return false;
}
void MriWatcherGUI::LoadFile(const QString& filename)
{
ReaderType::Pointer reader = ReaderType::New();
ImageType::Pointer image = reader->GetOutput();
reader->SetFileName( filename.toLatin1().constData() );
try
{
reader->Update();
}
catch( itk::ExceptionObject & e )
{
// std::cerr << "Exception in file reader " << std::endl;
// std::cerr << e << std::endl;
QMessageBox::information( this, "MriWatcher",
"Unable to load file:\n" + filename);
return;
}
m_numberofimages++;
ImageFrameGUI* m_imageframe = new ImageFrameGUI(m_frame);
connect(m_imageframe->g_imageframe, SIGNAL( Clicked(int) ), this, SLOT( ImageFrameClicked() ) );
connect(m_imageframe, SIGNAL( GetFiles(const QString &) ), this, SLOT( LoadOverlay(const QString &) ) );
m_imageframe->g_imageframe->SetManager(&m_imagemanager);
m_imageframe->g_imageframe->SetSlider(g_slice_slider);
m_imageframe->g_imageframe->SetId(m_direction);
QFileInfo info(filename);
m_imageframe->g_imageframe->SetImageName(info.baseName() );
m_imageframe->g_imageframe->DrawPosition(g_draw_position->isChecked() );
m_imageframe->g_imageframe->DrawIntensity(g_draw_intensity->isChecked() );
// This string should only be used for display purposes it is not
// safe to use this for comparison of types
// QString pixeltypestring(reader->GetImageIO()->GetComponentTypeInfo().name());
QString pixeltypestring(QString::fromStdString(reader->GetImageIO()->GetComponentTypeAsString(
reader->GetImageIO()->GetComponentType() ) ) );
m_imageframe->g_imageframe->DrawImageName(g_draw_name->isChecked() );
m_imagesize = image->GetLargestPossibleRegion().GetSize();
m_imagespacing = image->GetSpacing();
int m_cimagesize[3];
m_cimagesize[0] = m_imagesize[0];
m_cimagesize[1] = m_imagesize[1];
m_cimagesize[2] = m_imagesize[2];
float m_cpixdim[3];
m_cpixdim[0] = m_imagespacing[0];
m_cpixdim[1] = m_imagespacing[1];
m_cpixdim[2] = m_imagespacing[2];
m_imageframe->g_imageframe->SetImageInfo(m_cimagesize, m_cpixdim, pixeltypestring);
m_imageframe->g_imageframe->DrawImageInfo(g_draw_info->isChecked() );
typedef MinimumMaximumImageCalculator<ImageType> CalculatorType;
CalculatorType::Pointer calculator = CalculatorType::New();
calculator->SetImage(image);
calculator->Compute();
ImageType::PixelType m_min = calculator->GetMinimum();
ImageType::PixelType m_max = calculator->GetMaximum();
if( m_max > m_imagemax )
{
m_imagemax = m_max;
}
if( m_min < m_imagemin )
{
m_imagemin = m_min;
}
m_imageframe->g_imageframe->SetImageMinMax(m_min, m_max);
if( m_numberofimages == 1 )
{
m_imagemanager.SetSourceImage(image);
}
m_imageframe->g_imageframe->SetInputImage(image);
m_imageframe->g_imageframe->ChangeAlpha(100);
ReDraw();
g_slice_slider->setEnabled(true);
m_frame->setGeometry(QRect(m_frame->x(), m_frame->y(), m_frame->height(), m_frame->width() ) );
// gridLayout_imageWindows->addWidget(m_imageframe);
m_imageframelayout->addWidget(m_imageframe);
m_imageframelist.push_back(m_imageframe);
// m_imageframe->setLayout(m_imageframelayout);
m_imageframe->show();
// g_scrollArea->setWidget(m_imageframe);
if( m_imageframelist.size() == 1 )
{
m_imagemanager.SetCrosshair(m_imagesize[0] / 2, m_imagesize[1] / 2, m_imagesize[2] / 2);
}
else
{
m_imagemanager.UpdateCrosshair();
}
if( m_imagesize[0] > m_maxsize[0] )
{
m_maxsize[0] = m_imagesize[0];
}
if( m_imagesize[1] > m_maxsize[1] )
{
m_maxsize[1] = m_imagesize[1];
}
if( m_imagesize[2] > m_maxsize[2] )
{
m_maxsize[2] = m_imagesize[2];
}
UpdateLabel();
/*
if (!filename.isEmpty()) {
QImage image(filename);
if (image.isNull()) {
QMessageBox::information(this, tr("Image Viewer"),
tr("Cannot load %1.").arg(filename));
return;
}
// imageLabel->setPixmap(QPixmap::fromImage(image));
}
*/
}
// ---------------------------------------------------------
// CPosPSYListView::ActivateL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosPSYListView::ActivateL()
{
ReDraw();
}
// ---------------------------------------------------------
// CPosPSYStartView::ActivateL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosPSYStartView::ActivateL()
{
ReDraw();
}
void
ObjectView::MessageReceived(BMessage *inMsg)
{
BPoint delta(0, 0), where(0, 0);
if (inMsg->WasDropped()) {
where = inMsg->DropPoint(&delta);
ConvertFromScreen(&where);
}
switch (inMsg->what) {
case REDISPLAY_OBJECT: {
BRect r;
BMessageQueue *q = Window()->MessageQueue();
BMessage *m=nullptr;
if (inMsg->HasRect("rect")) {
r = inMsg->FindRect("rect");
} else {
r = Bounds();
}
for (int count=0; m=q->FindMessage(REDISPLAY_OBJECT, count); count++) {
ObjectView *ov=nullptr;
m->FindPointer("object", (void**)&ov);
if (ov == this) {
BRect s;
if (m->HasRect("rect")) {
s = m->FindRect("rect");
s.left = Min(s.left,r.left);
s.right = Max(s.right, r.right);
m->ReplaceRect("rect", s);
} else {
s = r;
m->AddRect("rect", s);
}
return;
}
}
Draw(r);
break;
}
case SET_COLOR: {
rgb_color *p;
ssize_t sz;
inMsg->FindData("color", B_RAW_TYPE, (const void **)&p, &sz);
color.red = p->red;
color.green = p->green;
color.blue = p->blue;
ReDraw();
break;
}
case SET_DISPLAY_MODE: {
rgb_color *p;
int32 md = inMsg->FindInt32("display mode");
SetDisplayMode(md);
break;
}
default:
BView::MessageReceived(inMsg);
break;
}
}
/********************* Start of window procedure **********************/
MRESULT EXPENTRY MyWindowProc( HWND hwnd, USHORT msg, MPARAM mp1, MPARAM mp2 )
{
USHORT command; /* WM_COMMAND command value */
HPS hps; /* Presentation Space handle */
RECTL rc; /* Rectangle coordinates */
POINTL pt; /* String screen coordinates */
switch( msg )
{
case WM_CREATE:
if( State == RUNNING ) break;
/******************************************************************/
/* Window initialization is performed here in WM_CREATE processing*/
/* WinLoadString loads strings from the resource file. */
/******************************************************************/
InitIt( "DSTD32", Hab, hwnd );
ReDraw( hwnd );
break;
case WM_COMMAND:
/******************************************************************/
/* When the user chooses option 1, 2, or 3 from the Options pull- */
/* down, the text string is set to 1, 2, or 3, and */
/* WinInvalidateRegion sends a WM_PAINT message. */
/* When Exit is chosen, the application posts itself a WM_CLOSE */
/* message. */
/******************************************************************/
command = SHORT1FROMMP(mp1); /* Extract the command value */
switch (command)
{
case ID_LOAD:
if( State == RUNNING ) break;
if( State != NONE ) {
KillIt();
State = NONE;
}
if( LoadIt() ) {
State = LOADED;
}
ReDraw( hwnd );
break;
case ID_RUN:
if( State == RUNNING ) break;
State = RUNNING;
ReDraw( hwnd );
if( InHardMode ) {
WinLockInput( 0, FALSE );
InHardMode = FALSE;
}
State = RunIt() ? BROKE : TERMINATED;
if( HardMode ) {
WinLockInput( 0, TRUE );
InHardMode = TRUE;
}
ReDraw( hwnd );
break;
case ID_KILL:
if( State == RUNNING ) break;
if( InHardMode ) {
WinLockInput( 0, FALSE );
InHardMode = FALSE;
}
if( State != NONE ) {
KillIt();
State = NONE;
}
ReDraw( hwnd );
break;
case ID_HARD:
if( State == RUNNING ) break;
HardMode = !HardMode;
TellHardMode( HardMode ? (char)-1 : 0 );
ReDraw( hwnd );
break;
case ID_EXITPROG:
if( InHardMode ) {
WinLockInput( 0, FALSE );
InHardMode = FALSE;
}
if( State == RUNNING ) break;
WinPostMsg( hwnd, WM_CLOSE, 0L, 0L );
break;
default:
return WinDefWindowProc( hwnd, msg, mp1, mp2 );
}
break;
case WM_ERASEBACKGROUND:
/******************************************************************/
/* Return TRUE to request PM to paint the window background */
/* in SYSCLR_WINDOW. */
/******************************************************************/
return (MRESULT)( TRUE );
case WM_PAINT:
/******************************************************************/
/* Window contents are drawn here in WM_PAINT processing. */
/******************************************************************/
/* Create a presentation space */
hps = WinBeginPaint( hwnd, NULL, &rc );
pt.x = 50; pt.y = 50; /* Set the text coordinates, */
GpiSetColor( hps, CLR_NEUTRAL ); /* colour of the text, */
GpiSetBackColor( hps, CLR_BACKGROUND ); /* its background and */
GpiSetBackMix( hps, BM_OVERPAINT ); /* how it mixes, */
/* and draw the string...*/
strcpy( WhatItIs[ State ] +HARD_POS, IsHardMode[ HardMode ] );
GpiCharStringAt( hps, &pt, (LONG)strlen( WhatItIs[ State ] ), WhatItIs[ State ] );
WinEndPaint( hps ); /* Drawing is complete */
break;
case WM_CLOSE:
/******************************************************************/
/* This is the place to put your termination routines */
/******************************************************************/
if( State == RUNNING ) break;
FiniIt();
WinPostMsg( hwnd, WM_QUIT, 0L, 0L ); /* Cause termination */
break;
default:
/******************************************************************/
/* Everything else comes here. This call MUST exist */
/* in your window procedure. */
/******************************************************************/
return WinDefWindowProc( hwnd, msg, mp1, mp2 );
}
return FALSE;
}
LRESULT FAR PASCAL WndProc( HWND hWnd,
UINT Message,
WPARAM wParam,
LPARAM lParam)
{
DWORD dwImmRet = 0; // return value of ImmSrvProcessKey()
try {
switch (Message)
{
case CONIME_CREATE:
DBGPRINT(("CONIME: CONIME_CREATE: Console Handle=%08x\n", wParam));
return InsertNewConsole(hWnd,(HANDLE)wParam,(HWND)lParam);
case CONIME_DESTROY:
DBGPRINT(("CONIME: CONIME_DESTROY: Console Handle=%08x\n", wParam));
return RemoveConsole(hWnd, (HANDLE)wParam);
case CONIME_SETFOCUS:
DBGPRINT(("CONIME: CONIME_SETFOCUS: Console Handle=%08x\n", wParam));
return ConsoleSetFocus(hWnd, (HANDLE)wParam, (HKL)lParam);
case CONIME_KILLFOCUS:
DBGPRINT(("CONIME: CONIME_KILLFOCUS: Console Handle=%08x\n", wParam));
return ConsoleKillFocus(hWnd, (HANDLE)wParam);
case CONIME_GET_NLSMODE:
DBGPRINT(("CONIME: CONIME_GET_NLSMODE: Console Handle=%08x\n", wParam));
return GetNLSMode(hWnd, (HANDLE)wParam);
case CONIME_SET_NLSMODE:
DBGPRINT(("CONIME: CONIME_SET_NLSMODE: Console Handle=%08x\n", wParam));
return SetNLSMode(hWnd, (HANDLE)wParam, (DWORD)lParam);
case CONIME_HOTKEY:
DBGPRINT(("CONIME: CONIME_HOTKEY\n"));
return ConimeHotkey(hWnd, (HANDLE)wParam, (DWORD)lParam);
case CONIME_NOTIFY_VK_KANA:
DBGPRINT(("CONIME: CONIME_NOTIFY_VK_KANA\n"));
return ImeUISetConversionMode(hWnd);
case CONIME_NOTIFY_SCREENBUFFERSIZE: {
COORD ScreenBufferSize;
DBGPRINT(("CONIME: CONIME_NOTIFY_SCREENBUFFERSIZE: Console Handle=%08x\n", wParam));
ScreenBufferSize.X = LOWORD(lParam);
ScreenBufferSize.Y = HIWORD(lParam);
return ConsoleScreenBufferSize(hWnd, (HANDLE)wParam, ScreenBufferSize);
}
case CONIME_INPUTLANGCHANGE: {
DBGPRINT(("CONIME: CONIME_INPUTLANGCHANGE: Console Handle=%08x \n",wParam));
ConImeInputLangchange(hWnd, (HANDLE)wParam, (HKL)lParam );
return TRUE;
}
case CONIME_NOTIFY_CODEPAGE: {
BOOL Output;
WORD Codepage;
Codepage = HIWORD(lParam);
Output = LOWORD(lParam);
DBGPRINT(("CONIME: CONIME_NOTIFY_CODEPAGE: Console Handle=%08x %04x %04x\n",wParam, Output, Codepage));
return ConsoleCodepageChange(hWnd, (HANDLE)wParam, Output, Codepage);
}
case WM_KEYDOWN +CONIME_KEYDATA:
case WM_KEYUP +CONIME_KEYDATA:
case WM_SYSKEYDOWN +CONIME_KEYDATA:
case WM_SYSKEYUP +CONIME_KEYDATA:
case WM_DEADCHAR +CONIME_KEYDATA:
case WM_SYSDEADCHAR+CONIME_KEYDATA:
case WM_SYSCHAR +CONIME_KEYDATA:
case WM_CHAR +CONIME_KEYDATA:
CharHandlerFromConsole( hWnd, Message, (ULONG)wParam, (ULONG)lParam );
break;
case WM_KEYDOWN:
case WM_KEYUP:
case WM_SYSKEYDOWN:
case WM_SYSKEYUP:
case WM_DEADCHAR:
case WM_SYSDEADCHAR:
case WM_SYSCHAR:
case WM_CHAR:
CharHandlerToConsole( hWnd, Message, (ULONG)wParam, (ULONG)lParam );
break;
case WM_INPUTLANGCHANGE:
DBGPRINT(("CONIME: CONIME_INPUTLANGCHANGE: Console Handle=%08x \n",wParam));
InputLangchange(hWnd, (DWORD)wParam, (HKL)lParam );
return TRUE;
case WM_INPUTLANGCHANGEREQUEST:
// Console IME never receive this message for this window is hidden
// and doesn't have focus.
//
// However, Hot key of IME_CHOTKEY_IME_NONIME_TOGGLE/IME_THOTKEY_IME_NONIME_TOGGLE
// are send this message by ImmSimulateHotKey API.
//
// If nothing processing by this message, then DefWindowProc calls
// ActivateKeyboardLayout on kernel side.
// And, ActivateKeyboardLayout send WM_INPUTLANGCHANGE message to focus window
// on this message queue.
// It window is console window procedure.
// Console window procedure can do send CONIME_INPUTLANGCHANGE message to
// console IME window.
// In console window is windowed case, this sequence as well.
// But, In console window is full screen case, message queue have not focus.
// WM_INPUTLANGCHANGE message can not send to console window procedure.
//
// This code avoid console full screen mode problem.
// Send message to console window procedure when this window receive it.
//
{
PCONSOLE_TABLE ConTbl;
ConTbl = SearchConsole(LastConsole);
if (ConTbl == NULL) {
return DefWindowProc(hWnd, Message, wParam, lParam);
}
PostMessage(ConTbl->hWndCon, Message, wParam, lParam);
}
return TRUE; // TRUE : process this message by application
case CONIME_INPUTLANGCHANGEREQUEST:
DBGPRINT(("CONIME: CONIME_INPUTLANGCHANGEREQUEST: Console Handle=%08x \n",wParam));
return ConImeInputLangchangeRequest(hWnd, (HANDLE)wParam, (HKL)lParam, CONIME_DIRECT);
case CONIME_INPUTLANGCHANGEREQUESTFORWARD:
DBGPRINT(("CONIME: CONIME_INPUTLANGCHANGEREQUEST: Console Handle=%08x \n",wParam));
return ConImeInputLangchangeRequest(hWnd, (HANDLE)wParam, (HKL)lParam, CONIME_FORWARD);
case CONIME_INPUTLANGCHANGEREQUESTBACKWARD:
DBGPRINT(("CONIME: CONIME_INPUTLANGCHANGEREQUEST: Console Handle=%08x \n",wParam));
return ConImeInputLangchangeRequest(hWnd, (HANDLE)wParam, (HKL)lParam, CONIME_BACKWARD);
#ifdef DEBUG_MODE
case WM_MOVE:
ImeUIMoveCandWin( hWnd );
break;
case WM_COMMAND: // message: command from application menu
// Message packing of wparam and lparam have changed for Win32,
// so use the GET_WM_COMMAND macro to unpack the commnad
switch (LOWORD(wParam)) {
case MM_EXIT:
PostMessage(hWnd,WM_CLOSE,0,0L);
break;
case MM_ACCESS_VIOLATION:
{
PBYTE p = 0;
*p = 0;
}
break;
}
break;
#endif
case WM_IME_STARTCOMPOSITION:
ImeUIStartComposition( hWnd );
break;
case WM_IME_ENDCOMPOSITION:
ImeUIEndComposition( hWnd );
break;
case WM_IME_COMPOSITION:
ImeUIComposition( hWnd, wParam, lParam );
break;
case WM_IME_COMPOSITIONFULL:
break;
case WM_IME_NOTIFY:
if ( !ImeUINotify( hWnd, wParam, lParam ) ) {
return DefWindowProc(hWnd, Message, wParam, lParam);
}
break;
case WM_IME_SETCONTEXT:
//
// The application have to pass WM_IME_SETCONTEXT to DefWindowProc.
// When the application want to handle the IME at the timing of
// focus changing, the application should use WM_GETFOCUS or
// WM_KILLFOCUS.
//
lParam &= ~ISC_SHOWUIALL;
return DefWindowProc( hWnd, Message, wParam, lParam );
case WM_IME_SYSTEM:
switch (wParam) {
case IMS_CLOSEPROPERTYWINDOW:
case IMS_OPENPROPERTYWINDOW:
ImeSysPropertyWindow(hWnd, wParam, lParam);
break;
default:
return DefWindowProc( hWnd, Message, wParam, lParam );
}
break;
case WM_CREATE:
return Create(hWnd);
break;
case WM_DESTROY:
DBGPRINT(("CONIME:Recieve WM_DESTROY\n"));
ExitList(hWnd);
PostQuitMessage(0);
return 0;
break;
case WM_CLOSE:
DBGPRINT(("CONIME:Recieve WM_CLOSE\n"));
DestroyWindow(hWnd);
return 0;
break;
case WM_ENABLE:{
PCONSOLE_TABLE FocusedConsole;
if (!wParam) {
FocusedConsole = SearchConsole(LastConsole);
if (FocusedConsole != NULL &&
FocusedConsole->hConsole != NULL) {
FocusedConsole->Enable = FALSE;
EnableWindow(FocusedConsole->hWndCon,FALSE);
gfDoNotKillFocus = TRUE;
}
}
else{
DWORD i;
LockConsoleTable();
for ( i = 1; i < NumberOfConsoleTable; i ++){
FocusedConsole = ConsoleTable[i];
if (FocusedConsole != NULL)
{
if ((FocusedConsole->hConsole != NULL)&&
(!FocusedConsole->Enable)&&
(!IsWindowEnabled(FocusedConsole->hWndCon))){
EnableWindow(FocusedConsole->hWndCon,TRUE);
FocusedConsole->Enable = TRUE;
if (!FocusedConsole->LateRemove)
SetForegroundWindow(FocusedConsole->hWndCon);
}
}
}
UnlockConsoleTable();
}
return DefWindowProc(hWnd, Message, wParam, lParam);
break;
}
#ifdef DEBUG_MODE
case WM_SETFOCUS:
CreateCaret( hWnd,
NULL,
IsUnicodeFullWidth( ConvertLine[xPos] ) ?
CaretWidth*2 : CaretWidth,
(UINT)cyMetrics );
SetCaretPos( xPos * cxMetrics, 0 );
ShowCaret( hWnd );
break;
case WM_KILLFOCUS:
HideCaret( hWnd );
DestroyCaret();
break;
case WM_PAINT:
{
PAINTSTRUCT pstruc;
HDC hDC;
hDC = BeginPaint(hWnd,&pstruc);
ReDraw(hWnd);
EndPaint(hWnd,&pstruc);
break;
}
#endif
case WM_QUERYENDSESSION:
#ifdef HIRSHI_DEBUG
/*
* If specified ntsd debugger on this process,
* then never catch WM_QUERYENDSESSION when logoff/shutdown because
* this process will terminate when ntsd process terminated.
*/
{
int i;
i = MessageBox(hWnd,TEXT("Could you approve exit session?"), TEXT("Console IME"),
MB_ICONSTOP | MB_YESNO);
return (i == IDYES ? TRUE : FALSE);
}
#endif
return TRUE; // Logoff or shutdown time.
case WM_ENDSESSION:
DBGPRINT(("CONIME:Recieve WM_ENDSESSION\n"));
ExitList(hWnd);
return 0;
default: // Passes it on if unproccessed
return DefWindowProc(hWnd, Message, wParam, lParam);
}
} except (InputExceptionFilter(GetExceptionInformation())) {
if (dwConsoleThreadId)
{
DBGPRINT(("CONIME: Exception on WndProc!!\n"));
UnregisterConsoleIME();
dwConsoleThreadId = 0;
DestroyWindow(hWnd);
return 0;
}
}
return TRUE;
}
