Exemple #1
0
void Manager::CloseAll()
{
	_MANAGER(CleverSysLog clv(L"Manager::CloseAll()"));
	while(!m_modalWindows.empty())
	{
		DeleteWindow(m_modalWindows.back());
		Commit();
	}
	while(!m_windows.empty())
	{
		DeleteWindow(m_windows.back());
		Commit();
	}
	m_windows.clear();
}
Exemple #2
0
void CreateWindow(const char* Title, int Width, int Height, bool Fullscren)
{
    if(g_Surface)
        DeleteWindow();

	if(SDL_Init(SDL_INIT_VIDEO|SDL_INIT_TIMER) < 0)
		return;

	unsigned int Flags = SDL_OPENGL | SDL_DOUBLEBUF;

	if(Fullscren)
		Flags |= SDL_FULLSCREEN;

	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 0);
    SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 0);
    SDL_GL_SetAttribute(SDL_GL_ACCUM_RED_SIZE, 0);
    SDL_GL_SetAttribute(SDL_GL_ACCUM_GREEN_SIZE, 0);
    SDL_GL_SetAttribute(SDL_GL_ACCUM_BLUE_SIZE, 0);
    SDL_GL_SetAttribute(SDL_GL_ACCUM_ALPHA_SIZE, 0);

	if((g_Surface = SDL_SetVideoMode(Width, Height, 32, Flags)) == 0)
		return;

	SDL_WM_SetCaption(Title, Title);
}
// 注意Pop窗口都位于最上层
void CAwsContainer::DestroyPopWnd(int nCount)
{
	// 找到顶层窗口
	if ( nCount > 0 )
	{
		CAwsContainer* pParent = (CAwsContainer*)GetParent();
		if ( ESP_NULL != pParent )
		{
			pParent->DestroyPopWnd(nCount);
		}
		else if ( m_nPopWndCount > 0 )
		{
			if ( nCount > m_nPopWndCount )
				nCount = m_nPopWndCount;

			while ( nCount > 0 )
			{
				--m_nPopWndCount;

				DeleteWindow(m_pSubWndData[m_nSubWndCount - 1], true);

				--nCount;
			}

			if ( 0 == m_nPopWndCount && ESP_NULL != m_pFocusWnd )
			{
				// 焦点窗口重新获得焦点
				m_pFocusWnd->OnFocus(true);
			}
		}
	}
}
Exemple #4
0
void
ScanBluetoothLeWidget::Unprepare()
{
  Notify::ClearNotification();

  DeleteWindow();
}
Exemple #5
0
static WindowPtr
createOverlayWindow (ScreenPtr pScreen)
{
    int wid = FakeClientID(0);
    WindowPtr pWin;
    XID overrideRedirect = TRUE;
    int result;

    pWin = CreateWindow (
	        wid, WindowTable[pScreen->myNum],
    	        0, 0, pScreen->width, pScreen->height, 0, 
	        InputOutput, CWOverrideRedirect, &overrideRedirect,
	        WindowTable[pScreen->myNum]->drawable.depth, 
	        serverClient, pScreen->rootVisual, &result);
    if (pWin == NULL) {
	return NULL;
    }

    if (!AddResource(wid, RT_WINDOW, (pointer)pWin)) {
	DeleteWindow(pWin, None);
	return NULL;
    }

    return pWin;
}
Exemple #6
0
RowFormWidget::~RowFormWidget()
{
  /* destroy all rows */
  for (auto &i : rows)
    i.Delete();

  if (IsDefined())
    DeleteWindow();
}
Exemple #7
0
/*!***************************************************************************
 @Function			DeleteAllWindows
 @Description		Delete all windows.
*****************************************************************************/
void CPVRTPrint3D::DeleteAllWindows()
{
#if !defined (DISABLE_PRINT3D)

	int unsigned i;

	for (i=0; i<PVRTPRINT3D_MAX_WINDOWS; i++)
		DeleteWindow (i);

#endif
}
Exemple #8
0
//______________________________________________________________________________
void KVFileDialog::CloseWindow()
{
   // Close file dialog.

   if (fFileInfo->fFilename)
      delete [] fFileInfo->fFilename;
   fFileInfo->fFilename = 0;
   if (fFileInfo->fFileNamesList != 0) {
      fFileInfo->fFileNamesList->Delete();
      fFileInfo->fFileNamesList = 0;
   }
   DeleteWindow();
}
Exemple #9
0
X11Renderer::~X11Renderer() {	
	m_pFrameQueue->WakeWait();
	Stop();
	delete m_pFrameQueue;

	for (int i = 0; i < FRAME_QUEUE_LEN; i++)
		delete m_pFrameQueueBufs[i];
	
	DeleteWindow();
	UninitVideo();

	delete[] m_RgbBuf;
}
Exemple #10
0
void
ManagedFileListWidget::Unprepare()
{
#ifdef HAVE_DOWNLOAD_MANAGER
  Timer::Cancel();

  if (Net::DownloadManager::IsAvailable())
    Net::DownloadManager::RemoveListener(*this);

  ClearNotification();
#endif

  DeleteWindow();
}
Exemple #11
0
/* for lack of a better way, a window is created that covers the area and
   when its deleted, it's invalidated */
static int
rdpInvalidateArea(ScreenPtr pScreen, int x, int y, int cx, int cy)
{
    WindowPtr pWin;
    int result;
    int attri;
    XID attributes[4];
    Mask mask;

    DEBUG_OUT(("rdpInvalidateArea:\n"));
    mask = 0;
    attri = 0;
    attributes[attri++] = pScreen->blackPixel;
    mask |= CWBackPixel;
    attributes[attri++] = xTrue;
    mask |= CWOverrideRedirect;

    if (g_wid == 0)
    {
        g_wid = FakeClientID(0);
    }

    pWin = CreateWindow(g_wid, pScreen->root,
                        x, y, cx, cy, 0, InputOutput, mask,
                        attributes, 0, serverClient,
                        wVisual(pScreen->root), &result);

    if (result == 0)
    {
        g_invalidate_window = pWin;
        MapWindow(pWin, serverClient);
        DeleteWindow(pWin, None);
        g_invalidate_window = pWin;
    }

    return 0;
}
Exemple #12
0
int main(int argc, char* argv[])
{
    CreateWindow("GLM core and GLM extensions for intermediate mode", 640, 480, false);

	Begin(640, 480);

	bool Exit = false;
    while(!Exit)
    {
		SDL_Event Event;

		while(SDL_PollEvent(&Event))
		{
			switch(Event.type)
			{
			case SDL_QUIT:
			case SDL_KEYDOWN:
				Exit = true;
				break;
			}
		}

		static float Time = 0.0f;
		Time += 0.1f;

		Render(Time);

		SDL_GL_SwapBuffers();
	}

	End();

    DeleteWindow();

    return 0;
}
 virtual void Unprepare() {
   DeleteWindow();
 }
Exemple #14
0
void
PlaneListWidget::Unprepare()
{
  DeleteWindow();
}
Exemple #15
0
void
PanelWidget::Unprepare()
{
  DeleteWindow();
}
Exemple #16
0
SolidWidget::~SolidWidget()
{
  delete widget;
  DeleteWindow();
}
void
GaugeThermalAssistant::Unprepare()
{
  DeleteWindow();
  OverlappedWidget::Unprepare();
}
Exemple #18
0
 virtual void Unprepare() override {
   Timer::Cancel();
   DeleteWindow();
 }
 virtual void Unprepare() override {
   DeleteWindow();
 }
Exemple #20
0
void
TaskListPanel::Unprepare()
{
  delete task_store;
  DeleteWindow();
}
Exemple #21
0
//______________________________________________________________________________
Bool_t KVFileDialog::ProcessMessage(Long_t msg, Long_t parm1, Long_t)
{
   // Process messages generated by the user input in the file dialog.

   if (!fFc->GetDisplayStat()) return kTRUE;  // Cancel button was pressed
   
   TGTreeLBEntry *e;
   TGTextLBEntry *te;
   TGFileItem *f;
   void *p = 0;
   TString txt;
   TString sdir = gSystem->WorkingDirectory();

   switch (GET_MSG(msg)) {
      case kC_COMMAND:
         switch (GET_SUBMSG(msg)) {
            case kCM_BUTTON:
               switch (parm1) {
                  case kIDF_OK:
                     // same code as under kTE_ENTER
                     if ((fDlgMode!=kKVFDDirectory) && (fTbfname->GetTextLength() == 0)) {
                        txt = "Please provide file name or use \"Cancel\"";
                        new TGMsgBox(fClient->GetRoot(), GetMainFrame(),
                                     "Missing File Name", txt, kMBIconExclamation,
                                     kMBOk);
                        return kTRUE;
                     } else if (!gSystem->AccessPathName(fTbfname->GetString(), kFileExists) &&
                                !strcmp(fOk->GetTitle(), "Save") &&
                                (!(fCheckB->GetState() == kButtonDown))) {
                        Int_t ret;
                        txt = TString::Format("File name %s already exists, OK to overwrite it?",
                                              fTbfname->GetString());
                        new TGMsgBox(fClient->GetRoot(), GetMainFrame(),
                                     "File Name Exist", txt.Data(), kMBIconExclamation,
                                     kMBYes | kMBNo, &ret);
                        if (ret == kMBNo)
                           return kTRUE;
                     }
                     if (fFileInfo->fMultipleSelection) {
                        if (fFileInfo->fFilename)
                           delete [] fFileInfo->fFilename;
                        fFileInfo->fFilename = 0;
                     }
                     else {
                        if (fFileInfo->fFilename)
                           delete [] fFileInfo->fFilename;
                        if (gSystem->IsAbsoluteFileName(fTbfname->GetString()))
                           fFileInfo->fFilename = StrDup(fTbfname->GetString());
                        else
                           fFileInfo->fFilename = gSystem->ConcatFileName(fFc->GetDirectory(),
                                                                          fTbfname->GetString());
                        fFileInfo->fFilename = StrDup(gSystem->UnixPathName(gSystem->ExpandPathName(fFileInfo->fFilename)));
                     }
                     if (fCheckB && (fCheckB->GetState() == kButtonDown))
                        fFileInfo->fOverwrite = kTRUE;
                     else
                        fFileInfo->fOverwrite = kFALSE;
                     DeleteWindow();
                     break;

                  case kIDF_CANCEL:
                     if (fFileInfo->fFilename)
                        delete [] fFileInfo->fFilename;
                     fFileInfo->fFilename = 0;
                     if (fFc->GetDisplayStat()) 
                        fFc->SetDisplayStat(kFALSE);
                     if (fFileInfo->fFileNamesList != 0) {
                        fFileInfo->fFileNamesList->Delete();
                        fFileInfo->fFileNamesList = 0;
                     }
                     DeleteWindow();
                     return kTRUE;   //no need to redraw fFc
                     break;

                  case kIDF_CDUP:
                     fFc->ChangeDirectory("..");
                     fTreeLB->Update(fFc->GetDirectory());
                     if (fFileInfo->fIniDir) delete [] fFileInfo->fIniDir;
                     fFileInfo->fIniDir = StrDup(fFc->GetDirectory());
                     if (strcmp(gSystem->WorkingDirectory(),fFc->GetDirectory())) {
                        gSystem->cd(fFc->GetDirectory());
                     }
                     break;

                  case kIDF_NEW_FOLDER: {
                     char answer[128];
                     strlcpy(answer, "(empty)", sizeof(answer));
                     new TGInputDialog(gClient->GetRoot(), GetMainFrame(),
                                       "Enter directory name:",
                                       answer/*"(empty)"*/, answer);

                     while ( strcmp(answer, "(empty)") == 0 ) {
                        new TGMsgBox(gClient->GetRoot(), GetMainFrame(), "Error",
                                     "Please enter a valid directory name.",
                                     kMBIconStop, kMBOk);
                        new TGInputDialog(gClient->GetRoot(), GetMainFrame(),
                                          "Enter directory name:",
                                          answer, answer);
                     }
                     if ( strcmp(answer, "") == 0 )  // Cancel button was pressed
                        break;
                     
                     if (strcmp(gSystem->WorkingDirectory(),fFc->GetDirectory())) {
                        gSystem->cd(fFc->GetDirectory());
                     }
                     if ( gSystem->MakeDirectory(answer) != 0 )
                        new TGMsgBox(gClient->GetRoot(), GetMainFrame(), "Error", 
                                     TString::Format("Directory name \'%s\' already exists!", answer),
                                     kMBIconStop, kMBOk);
                     else {
                        fFc->DisplayDirectory();
                     }
                     gSystem->ChangeDirectory(sdir.Data());
                     break;
                  }

                  case kIDF_LIST:
                     fFv->SetViewMode(kLVList);
                     fDetails->SetState(kButtonUp);
                     break;

                  case kIDF_DETAILS:
                     fFv->SetViewMode(kLVDetails);
                     fList->SetState(kButtonUp);
                     break;
               }
               break;

            case kCM_COMBOBOX:
               switch (parm1) {
                  case kIDF_FSLB:
                     e = (TGTreeLBEntry *) fTreeLB->GetSelectedEntry();
                     if (e) {
                        fFc->ChangeDirectory(e->GetPath()->GetString());
                        fTreeLB->Update(fFc->GetDirectory());
                        if (fFileInfo->fIniDir) delete [] fFileInfo->fIniDir;
                        fFileInfo->fIniDir = StrDup(fFc->GetDirectory());
                        if (strcmp(gSystem->WorkingDirectory(),fFc->GetDirectory())) {
                           gSystem->cd(fFc->GetDirectory());
                        }
                     }
                     break;

                  case kIDF_FTYPESLB:
                     te = (TGTextLBEntry *) fTypes->GetSelectedEntry();
                     if (te) {
                        //fTbfname->Clear();
                        //fTbfname->AddText(0, fFileInfo->fFileTypes[te->EntryId()+1]);
                        fFileInfo->fFileTypeIdx = te->EntryId();
                        fFc->SetFilter(fFileInfo->fFileTypes[fFileInfo->fFileTypeIdx+1]);
                        fFc->DisplayDirectory();
                        fClient->NeedRedraw(fName);
                     }
                     break;
               }
               break;

            default:
               break;
         } // switch(GET_SUBMSG(msg))
         break;

      case kC_CONTAINER:
         switch (GET_SUBMSG(msg)) {
            case kCT_ITEMCLICK:
               if (parm1 == kButton1) {
                  if (fFc->NumSelected() > 0) {
                     if ( fFileInfo->fMultipleSelection == kFALSE ) {
                        TGLVEntry *e2 = (TGLVEntry *) fFc->GetNextSelected(&p);
                        if ((e2) && !R_ISDIR(((TGFileItem *)e2)->GetType())) {
                           fTbfname->Clear();
                           if (e2->GetItemName())
                              fTbfname->AddText(0, e2->GetItemName()->GetString());
                           fClient->NeedRedraw(fName);
                        }
                     }
                     else {
                        TString tmpString;
                        TList *tmp = fFc->GetSelectedItems();
                        TObjString *el;
                        TIter next(tmp);
                        if ( fFileInfo->fFileNamesList != 0 ) {
                           fFileInfo->fFileNamesList->Delete();
                        }
                        else {
                           fFileInfo->fFileNamesList = new TList();
                        }
                        while ((el = (TObjString *) next())) {
                           char *s = gSystem->ConcatFileName(fFc->GetDirectory(),
                                                             el->GetString());
                           tmpString += "\"" + el->GetString() + "\" ";
                           fFileInfo->fFileNamesList->Add(new TObjString(s));
                           delete [] s;
                        }
                        fTbfname->Clear();
                        fTbfname->AddText(0, tmpString);
                        fClient->NeedRedraw(fName);
                     }
                  }
               }
               break;

            case kCT_ITEMDBLCLICK:

               if (parm1 == kButton1) {
                  if (fFc->NumSelected() == 1) {
                     f = (TGFileItem *) fFc->GetNextSelected(&p);
                     if (f && R_ISDIR(f->GetType())) {
                        fFc->ChangeDirectory(f->GetItemName()->GetString());
                        fTreeLB->Update(fFc->GetDirectory());
                        if (fFileInfo->fIniDir) delete [] fFileInfo->fIniDir;
                        fFileInfo->fIniDir = StrDup(fFc->GetDirectory());
                        if (strcmp(gSystem->WorkingDirectory(),fFc->GetDirectory())) {
                           gSystem->cd(fFc->GetDirectory());
                        }
                     } else {
                        if (!strcmp(fOk->GetTitle(), "Save") &&
                            (!(fCheckB->GetState() == kButtonDown))) {

                           Int_t ret;
                           txt = TString::Format("File name %s already exists, OK to overwrite it?",
                                                 fTbfname->GetString());
                           new TGMsgBox(fClient->GetRoot(), GetMainFrame(),
                                        "File Name Exist", txt.Data(), kMBIconExclamation,
                                        kMBYes | kMBNo, &ret);
                           if (ret == kMBNo)
                              return kTRUE;
                        }
                        if (fFileInfo->fFilename)
                           delete [] fFileInfo->fFilename;
                        if (gSystem->IsAbsoluteFileName(fTbfname->GetString()))
                           fFileInfo->fFilename = StrDup(fTbfname->GetString());
                        else
                           fFileInfo->fFilename = gSystem->ConcatFileName(fFc->GetDirectory(),
                                                                          fTbfname->GetString());
                        fFileInfo->fFilename = StrDup(gSystem->UnixPathName(gSystem->ExpandPathName(fFileInfo->fFilename)));
                        if (fCheckB && (fCheckB->GetState() == kButtonDown))
                           fFileInfo->fOverwrite = kTRUE;
                        else
                           fFileInfo->fOverwrite = kFALSE;

                        DeleteWindow();
                     }
                  }
               }

               break;

            default:
               break;

         } // switch(GET_SUBMSG(msg))
         break;

      case kC_TEXTENTRY:
         switch (GET_SUBMSG(msg)) {
            case kTE_ENTER:
               // same code as under kIDF_OK
               if ((fDlgMode!=kKVFDDirectory) && (fTbfname->GetTextLength() == 0)) {
                  const char *txt2 = "Please provide file name or use \"Cancel\"";
                  new TGMsgBox(fClient->GetRoot(), GetMainFrame(),
                               "Missing File Name", txt2, kMBIconExclamation,
                               kMBOk);
                  return kTRUE;
               } else if (!gSystem->AccessPathName(fTbfname->GetString(), kFileExists)) {
                  FileStat_t buf;
                  if (!gSystem->GetPathInfo(fTbfname->GetString(), buf) &&
                      R_ISDIR(buf.fMode)) {
                     fFc->ChangeDirectory(fTbfname->GetString());
                     fTreeLB->Update(fFc->GetDirectory());
                     if (strcmp(gSystem->WorkingDirectory(), fFc->GetDirectory())) {
                        gSystem->cd(fFc->GetDirectory());
                     }
                     fName->SetText("", kFALSE);
                     return kTRUE;
                  }
                  else if (!strcmp(fOk->GetTitle(), "Save") && 
                          (!(fCheckB->GetState() == kButtonDown))) {
                     Int_t ret;
                     txt = TString::Format("File name %s already exists, OK to overwrite it?",
                                           fTbfname->GetString());
                     new TGMsgBox(fClient->GetRoot(), GetMainFrame(),
                                  "File Name Exist", txt.Data(), kMBIconExclamation,
                                  kMBYes | kMBNo, &ret);
                     if (ret == kMBNo)
                        return kTRUE;
                  }
               }
               if (fFileInfo->fFilename)
                  delete [] fFileInfo->fFilename;
               fFileInfo->fFilename = gSystem->ConcatFileName(fFc->GetDirectory(),
                                                              fTbfname->GetString());
               fFileInfo->fFilename = StrDup(gSystem->UnixPathName(gSystem->ExpandPathName(fFileInfo->fFilename)));
               if (fCheckB && (fCheckB->GetState() == kButtonDown))
                  fFileInfo->fOverwrite = kTRUE;
               else
                  fFileInfo->fOverwrite = kFALSE;
               DeleteWindow();
               break;

            default:
               break;
         }
         break;

      default:
         break;

   } // switch(GET_MSG(msg))

   fClient->NeedRedraw(fFc);
   return kTRUE;
}
Exemple #22
0
/**
 *  응용프로그램의 C 언어 엔트리 포인트
 */
int Main( char* pcArgument )
{
    QWORD qwWindowID;
    int iX;
    int iY;
    int iWidth;
    int iHeight;
    TEXTINFO stInfo;
    int iMoveLine;
    EVENT stReceivedEvent;
    KEYEVENT* pstKeyEvent;
    WINDOWEVENT* pstWindowEvent;
    DWORD dwFileOffset;
    RECT stScreenArea;
    
    //--------------------------------------------------------------------------
    // 그래픽 모드 판단
    //--------------------------------------------------------------------------
    // MINT64 OS가 그래픽 모드로 시작했는지 확인
    if( IsGraphicMode() == FALSE )
    {        
        // MINT64 OS가 그래픽 모드로 시작하지 않았다면 실패
        printf( "This task can run only GUI mode~!!!\n" );
        return -1;
    }
    
    //--------------------------------------------------------------------------
    // 파일의 내용을 파일 버퍼에 저장하고 라인 별 파일 오프셋 저장용 버퍼를 생성
    //--------------------------------------------------------------------------
    // 인자에 아무것도 전달되지 않으면 실패
    if( strlen( pcArgument ) == 0 )
    {
        printf( "ex) exec textviwer.elf abc.txt\n" );
        return 0;
    }
        
    // 파일을 디렉터리에서 찾은 뒤에 파일의 크기만큼 메모리를 할당하여 파일을 저장
    // 라인 별 파일 오프셋을 저장할 버퍼도 같이 생성
    if( ReadFileToBuffer( pcArgument, &stInfo ) == FALSE )
    {
        printf( "%s file is not found\n", pcArgument );
        return 0;
    }

    //--------------------------------------------------------------------------
    // 윈도우와 라인 인덱스를 생성한 뒤 첫 번째 라인부터 화면에 출력
    //--------------------------------------------------------------------------
    // 윈도우를 화면 가운데에 가로 500 픽셀 X 세로 500 픽셀로 생성
    GetScreenArea( &stScreenArea );
    iWidth = 500;
    iHeight = 500;
    iX = ( GetRectangleWidth( &stScreenArea ) - iWidth ) / 2;
    iY = ( GetRectangleHeight( &stScreenArea ) - iHeight ) / 2;
    qwWindowID = CreateWindow(iX, iY, iWidth, iHeight, WINDOW_FLAGS_DEFAULT | 
                              WINDOW_FLAGS_RESIZABLE, "Text Viewer" );
    
    // 라인 별 파일 오프셋을 계산하고 현재 화면에 출력하는 라인 인덱스를 0으로 설정
    CalculateFileOffsetOfLine( iWidth, iHeight, &stInfo );
    stInfo.iCurrentLineIndex = 0;
    
    // 현재 라인부터 화면 전체 크기만큼을 표시
    DrawTextBuffer( qwWindowID, &stInfo );
        
    //--------------------------------------------------------------------------
    // GUI 태스크의 이벤트 처리 루프
    //--------------------------------------------------------------------------
    while( 1 )
    {
        // 이벤트 큐에서 이벤트를 수신
        if( ReceiveEventFromWindowQueue( qwWindowID, &stReceivedEvent ) == FALSE )
        {
            Sleep( 10 );
            continue;
        }
        
        // 수신된 이벤트를 타입에 따라 나누어 처리
        switch( stReceivedEvent.qwType )
        {
            // 키 눌림 처리
        case EVENT_KEY_DOWN:
            pstKeyEvent = &( stReceivedEvent.stKeyEvent );
            if( pstKeyEvent->bFlags & KEY_FLAGS_DOWN )
            {
                // 키 값에 따른 현재 라인 변경 값 설정
                switch( pstKeyEvent->bASCIICode )
                {
                    // Page Up 키와 Page Down 키는 화면에 출력 가능한 라인 단위로 이동
                case KEY_PAGEUP:
                    iMoveLine = -stInfo.iRowCount;
                    break;
                case KEY_PAGEDOWN:
                    iMoveLine = stInfo.iRowCount;
                    break;
                    // Up 키와 Down 키는 한 라인 단위로 이동
                case KEY_UP:
                    iMoveLine = -1;
                    break;
                case KEY_DOWN:
                    iMoveLine = 1;
                    break;
                    
                    // 기타 키이거나 현재 위치에서 움직일 필요가 없으면 종료
                default:
                    iMoveLine = 0;
                    break;
                }
                
                // 최대 최소 라인 범위를 벗어나면 현재 라인 인덱스를 조정
                if( stInfo.iCurrentLineIndex + iMoveLine < 0 )
                {
                    iMoveLine = -stInfo.iCurrentLineIndex;
                }
                else if( stInfo.iCurrentLineIndex + iMoveLine >= stInfo.iMaxLineCount )
                {
                    iMoveLine = stInfo.iMaxLineCount - stInfo.iCurrentLineIndex - 1;
                }
                                
                // 기타 키이거나 움직일 필요가 없으면 종료
                if( iMoveLine == 0 )
                {
                    break;
                }
                        
                // 현재 라인의 인덱스를 변경하고 화면에 출력
                stInfo.iCurrentLineIndex += iMoveLine;
                DrawTextBuffer( qwWindowID, &stInfo );
            }
            break;
            
            // 윈도우 크기 변경 처리
        case EVENT_WINDOW_RESIZE:
            pstWindowEvent = &( stReceivedEvent.stWindowEvent );
            iWidth = GetRectangleWidth( &( pstWindowEvent->stArea ) );
            iHeight = GetRectangleHeight( &( pstWindowEvent->stArea ) );
            
            // 현재 라인이 있는 파일 오프셋을 저장
            dwFileOffset = stInfo.pdwFileOffsetOfLine[ stInfo.iCurrentLineIndex ];
            
            // 변경된 화면 크기로 다시 라인 수와 라인 당 문자 수, 그리고 파일 오프셋을 
            // 계산하고 이 값과 이전에 저장한 파일 오프셋을 이용하여 현재 라인을 다시 계산
            CalculateFileOffsetOfLine( iWidth, iHeight, &stInfo );
            stInfo.iCurrentLineIndex = dwFileOffset / stInfo.iColumnCount;
            
            // 현재 라인부터 화면에 출력
            DrawTextBuffer( qwWindowID, &stInfo );
            break;
            
            // 윈도우 닫기 버튼 처리
        case EVENT_WINDOW_CLOSE:
            // 윈도우를 삭제하고 메모리를 해제
            DeleteWindow( qwWindowID );
            free( stInfo.pbFileBuffer );
            free( stInfo.pdwFileOffsetOfLine );
            return 0;
            break;
            
            // 그 외 정보
        default:
            break;
        }
    }
    
    return 0;
}
void
ProfileListWidget::Unprepare()
{
  DeleteWindow();
}
 ~PageListWidget() {
   if (IsDefined())
     DeleteWindow();
 }
Exemple #25
0
void
GaugeFLARM::Unprepare()
{
  DeleteWindow();
  OverlappedWidget::Unprepare();
}
void
CrossSectionWidget::Unprepare()
{
  DeleteWindow();
}
Exemple #27
0
//------------------------------ DeleteMenu --------------------------------------
//
void DeleteMenu ()
{
	DeleteWindow (_menuHndl);
	return;
}
Exemple #28
0
void
HorizonWidget::Unprepare()
{
  DeleteWindow();
}
Exemple #29
0
void
NOAAListWidget::Unprepare()
{
  DeleteWindow();
}
Exemple #30
0
/**
 *  응용프로그램의 C 언어 엔트리 포인트
 */
int Main( char* pcArgument )
{
    QWORD qwWindowID;
    int iX;
    int iY;
    int iWidth;
    int iHeight;
    EVENT stReceivedEvent;
    KEYEVENT* pstKeyEvent;
    WINDOWEVENT* pstWindowEvent;
    RECT stScreenArea;
    BUFFERMANAGER stBufferManager;
    BOOL bHangulMode;
    
    //--------------------------------------------------------------------------
    // 그래픽 모드 판단
    //--------------------------------------------------------------------------
    // MINT64 OS가 그래픽 모드로 시작했는지 확인
    if( IsGraphicMode() == FALSE )
    {        
        // MINT64 OS가 그래픽 모드로 시작하지 않았다면 실패
        printf( "This task can run only GUI mode~!!!\n" );
        return -1;
    }
    
    //--------------------------------------------------------------------------
    // 윈도우와 입력 위치를 나타내는 커서를 생성
    //--------------------------------------------------------------------------
    // 윈도우를 화면 가운데에 가로 X 세로 크기를 60문자 X 40 픽셀로 생성
    GetScreenArea( &stScreenArea );
    iWidth = MAXOUTPUTLENGTH * FONT_ENGLISHWIDTH + 5;
    iHeight = 40;
    iX = ( GetRectangleWidth( &stScreenArea ) - iWidth ) / 2;
    iY = ( GetRectangleHeight( &stScreenArea ) - iHeight ) / 2;
    qwWindowID = CreateWindow(iX, iY, iWidth, iHeight, WINDOW_FLAGS_DEFAULT,
                              "한 줄 메모장(한/영 전환은 Alt 키)" );
    
    // 버퍼의 정보를 초기화하고 영문 입력 모드로 설정
    memset( &stBufferManager, 0, sizeof( stBufferManager ) );
    bHangulMode = FALSE;

    // 커서를 메모 입력 영역 앞쪽에 세로로 길게 출력하고 윈도우를 다시 표시
    DrawRect( qwWindowID, 3, 4 + WINDOW_TITLEBAR_HEIGHT, 5,
        3 + WINDOW_TITLEBAR_HEIGHT + FONT_ENGLISHHEIGHT, RGB( 0, 250, 0 ), TRUE );
    ShowWindow( qwWindowID, TRUE );

    //--------------------------------------------------------------------------
    // GUI 태스크의 이벤트 처리 루프
    //--------------------------------------------------------------------------
    while( 1 )
    {
        // 이벤트 큐에서 이벤트를 수신
        if( ReceiveEventFromWindowQueue( qwWindowID, &stReceivedEvent ) == FALSE )
        {
            Sleep( 10 );
            continue;
        }
        
        // 수신된 이벤트를 타입에 따라 나누어 처리
        switch( stReceivedEvent.qwType )
        {
            // 키 눌림 처리
        case EVENT_KEY_DOWN:
            // 키 이벤트를 추출
            pstKeyEvent = &( stReceivedEvent.stKeyEvent );

            // 입력된 키로 한글을 조합하거나 영문을 출력
            switch( pstKeyEvent->bASCIICode )
            {
            //------------------------------------------------------------------
            // 한/영 모드 전환 처리
            //------------------------------------------------------------------
            case KEY_LALT:
                // 한글 입력 모드 중에 Alt 키가 눌러지면 한글 조합을 종료
                if( bHangulMode == TRUE )
                {
                    // 키 입력 버퍼를 초기화
                    stBufferManager.iInputBufferLength = 0;

                    if( ( stBufferManager.vcOutputBufferForProcessing[ 0 ] != '\0' ) &&
                        ( stBufferManager.iOutputBufferLength + 2 < MAXOUTPUTLENGTH ) )
                    {
                        // 조합 중인 한글을 윈도우 화면에 출력하는 버퍼로 복사
                        memcpy( stBufferManager.vcOutputBuffer +
                                stBufferManager.iOutputBufferLength,
                                stBufferManager.vcOutputBufferForProcessing, 2 );
                        stBufferManager.iOutputBufferLength += 2;

                        // 조합 중인 한글을 저장하는 버퍼를 초기화
                        stBufferManager.vcOutputBufferForProcessing[ 0 ] = '\0';
                    }
                }
                // 영문 입력 모드 중에 Alt 키가 눌러지면 한글 조합용 버퍼를 초기화
                else
                {
                    stBufferManager.iInputBufferLength = 0;
                    stBufferManager.vcOutputBufferForComplete[ 0 ] = '\0';
                    stBufferManager.vcOutputBufferForProcessing[ 0 ] = '\0';
                }
                bHangulMode = TRUE - bHangulMode;
                break;

            //------------------------------------------------------------------
            // 백스페이스 키 처리
            //------------------------------------------------------------------
            case KEY_BACKSPACE:
                // 한글을 조합하는 중이면 입력 버퍼의 내용을 삭제하고 남은
                // 키 입력 버퍼의 내용으로 한글을 조합
                if( ( bHangulMode == TRUE ) &&
                    ( stBufferManager.iInputBufferLength > 0 ) )
                {
                    // 키 입력 버퍼의 내용을 하나 제거하고 한글을 다시 조합
                    stBufferManager.iInputBufferLength--;
                    ComposeHangul( stBufferManager.vcInputBuffer,
                            &stBufferManager.iInputBufferLength,
                            stBufferManager.vcOutputBufferForProcessing,
                            stBufferManager.vcOutputBufferForComplete );
                }
                // 한글 조합 중이 아니면 윈도우 화면에 출력하는 버퍼의 내용을 삭제
                else
                {
                    if( stBufferManager.iOutputBufferLength > 0 )
                    {
                        // 화면 출력 버퍼에 들어있는 내용이 2바이트 이상이고 버퍼에
                        // 저장된 값에 최상위 비트가 켜져 있으면 한글로 간주하고
                        // 마지막 2바이트를 모두 삭제
                        if( ( stBufferManager.iOutputBufferLength >= 2 ) &&
                            ( stBufferManager.vcOutputBuffer[
                                  stBufferManager.iOutputBufferLength - 1 ] & 0x80 ) )
                        {
                            stBufferManager.iOutputBufferLength -= 2;
                            memset( stBufferManager.vcOutputBuffer +
                                    stBufferManager.iOutputBufferLength, 0, 2 );
                        }
                        // 한글이 아니면 마지막 1바이트만 삭제
                        else
                        {
                            stBufferManager.iOutputBufferLength--;
                            stBufferManager.vcOutputBuffer[
                                stBufferManager.iOutputBufferLength ] = '\0';
                        }
                    }
                }
                break;

            //------------------------------------------------------------------
            // 나머지 키들은 현재 입력 모드에 따라 한글을 조합하거나
            // 윈도우 화면에 출력하는 버퍼로 직접 삽입
            //------------------------------------------------------------------
            default:
                // 특수 키들은 모두 무시
                if( pstKeyEvent->bASCIICode & 0x80 )
                {
                    break;
                }

                // 한글 조합 중이면 한글 조합 처리(한글을 화면 출력 버퍼에 저장할
                // 공간이 충분한지도 확인)
                if( ( bHangulMode == TRUE ) &&
                    ( stBufferManager.iOutputBufferLength + 2 <= MAXOUTPUTLENGTH ) )
                {
                    // 자/모음이 시프트와 조합되는 경우를 대비하여 쌍자음이나
                    // 쌍모음을 제외한 나머지는 소문자로 변환
                    ConvertJaumMoumToLowerCharactor( &pstKeyEvent->bASCIICode );

                    // 입력 버퍼에 키 입력 값을 채우고 데이터의 길이를 증가
                    stBufferManager.vcInputBuffer[
                        stBufferManager.iInputBufferLength ] = pstKeyEvent->bASCIICode;
                    stBufferManager.iInputBufferLength++;

                    // 한글 조합에 필요한 버퍼를 넘겨줘서 한글을 조합
                    if( ComposeHangul( stBufferManager.vcInputBuffer,
                        &stBufferManager.iInputBufferLength,
                        stBufferManager.vcOutputBufferForProcessing,
                        stBufferManager.vcOutputBufferForComplete) == TRUE )
                    {
                        // 조합이 완료된 버퍼에 값이 있는가 확인하여 윈도우 화면에
                        // 출력할 버퍼로 복사
                        if( stBufferManager.vcOutputBufferForComplete[ 0 ] != '\0' )
                        {
                           memcpy( stBufferManager.vcOutputBuffer +
                                   stBufferManager.iOutputBufferLength,
                                   stBufferManager.vcOutputBufferForComplete, 2 );
                           stBufferManager.iOutputBufferLength += 2;

                           // 조합된 한글을 복사한 뒤에 현재 조합 중인 한글을 출력할
                           // 공간이 없다면 키 입력 버퍼와 조합 중인 한글 버퍼를 모두 초기화
                           if( stBufferManager.iOutputBufferLength + 2 > MAXOUTPUTLENGTH )
                           {
                               stBufferManager.iInputBufferLength = 0;
                               stBufferManager.vcOutputBufferForProcessing[ 0 ] = '\0';
                           }
                        }
                    }
                    // 조합에 실패하면 입력 버퍼에 마지막으로 입력된 값이 한글 자/모음이
                    // 아니므로 한글 조합이 완료된 버퍼의 값과 입력 버퍼에 있는 값을 모두
                    // 출력 버퍼로 복사
                    else
                    {
                        // 조합이 완료된 버퍼에 값이 있는가 확인하여 윈도우 화면에
                        // 출력할 버퍼로 복사
                        if( stBufferManager.vcOutputBufferForComplete[ 0 ] != '\0' )
                        {
                            // 완성된 한글을 출력 버퍼로 복사
                            memcpy( stBufferManager.vcOutputBuffer +
                                    stBufferManager.iOutputBufferLength,
                                    stBufferManager.vcOutputBufferForComplete, 2 );
                            stBufferManager.iOutputBufferLength += 2;
                        }

                        // 윈도우 화면에 출력하는 버퍼의 공간이 충분하면 키 입력 버퍼에
                        // 마지막으로 입력된 한글 자/모가 아닌 값을 복사
                        if( stBufferManager.iOutputBufferLength < MAXOUTPUTLENGTH )
                        {
                            stBufferManager.vcOutputBuffer[
                                stBufferManager.iOutputBufferLength ] =
                                        stBufferManager.vcInputBuffer[ 0 ];
                            stBufferManager.iOutputBufferLength++;
                        }

                        // 키 입력 버퍼를 비움
                        stBufferManager.iInputBufferLength = 0;
                    }
                }
                // 한글 입력 모드가 아닌 경우
                else if( ( bHangulMode == FALSE ) &&
                         ( stBufferManager.iOutputBufferLength + 1 <= MAXOUTPUTLENGTH ) )
                {
                    // 키 입력을 그대로 윈도우 화면에 출력하는 버퍼로 저장
                    stBufferManager.vcOutputBuffer[
                        stBufferManager.iOutputBufferLength ] = pstKeyEvent->bASCIICode;
                    stBufferManager.iOutputBufferLength++;
                }
                break;
            }

            //------------------------------------------------------------------
            // 화면 출력 버퍼에 있는 문자열과 조합 중인 한글을 출력하고 커서의
            // 위치를 갱신
            //------------------------------------------------------------------
            // 화면 출력 버퍼에 있는 문자열을 전부 출력
            DrawText( qwWindowID, 2, WINDOW_TITLEBAR_HEIGHT + 4, RGB( 0, 0, 0 ),
                      RGB( 255, 255, 255 ), stBufferManager.vcOutputBuffer,
                      MAXOUTPUTLENGTH );
            // 현재 조합 중인 한글이 있다면 화면 출력 버퍼의 내용이 출력된
            // 다음 위치에 조합중인 한글을 출력
            if( stBufferManager.vcOutputBufferForProcessing[ 0 ] != '\0' )
            {
                DrawText( qwWindowID, 2 + stBufferManager.iOutputBufferLength *
                          FONT_ENGLISHWIDTH, WINDOW_TITLEBAR_HEIGHT + 4,
                          RGB( 0, 0, 0 ), RGB( 255, 255, 255 ),
                          stBufferManager.vcOutputBufferForProcessing, 2 );
            }

            // 커서를 세로로 길게 출력
            DrawRect( qwWindowID, 3 + stBufferManager.iOutputBufferLength *
                      FONT_ENGLISHWIDTH, 4 + WINDOW_TITLEBAR_HEIGHT,
                      5 + stBufferManager.iOutputBufferLength * FONT_ENGLISHWIDTH,
                      3 + WINDOW_TITLEBAR_HEIGHT + FONT_ENGLISHHEIGHT,
                      RGB( 0, 250, 0 ), TRUE );

            ShowWindow( qwWindowID, TRUE );
            break;

            // 윈도우 닫기 버튼 처리
        case EVENT_WINDOW_CLOSE:
            // 윈도우를 삭제하고 메모리를 해제
            DeleteWindow( qwWindowID );
            return 0;
            break;
            
            // 그 외 정보
        default:
            break;
        }
    }
    
    return 0;
}