int main(int argc, char *argv[]) { struct thread_init_arg tia[MAX_WINDOWS]; struct window *h[MAX_WINDOWS]; HANDLE threads[MAX_WINDOWS]; int i; terminate = CreateEvent(NULL, TRUE, FALSE, NULL); if (initMainthread()) return -1; /* four windows and contexts sharing display lists and texture objects */ h[0] = AddWindow( 10, 10, gCtx); h[1] = AddWindow(330, 10, gCtx); h[2] = AddWindow( 10, 350, gCtx); h[3] = AddWindow(330, 350, gCtx); for (i = 0; i < NumWindows; i++) { Windows[i].hEventInitialised = CreateEvent(NULL, TRUE, FALSE, NULL); } for (i = 0; i < NumWindows; i++) { DWORD id; tia[i].id = i; threads[i] = CreateThread(NULL, 0, threadRunner, &tia[i], 0, &id); WaitForSingleObject(Windows[i].hEventInitialised, INFINITE); } if (!wglMakeCurrent(gHDC, gCtx)) { Error("wglMakeCurrent failed for init thread."); return -1; } InitGLstuff(); while (1) { MSG msg; /* wait 1 ms for signal either to exit or process messages */ switch (MsgWaitForMultipleObjects(NumWindows, threads, TRUE, 1, QS_ALLINPUT)) { case WAIT_OBJECT_0: return 0; } while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) { if (msg.message == WM_QUIT) { return 0; } TranslateMessage(&msg); DispatchMessage(&msg); } } return 0; }
gboolean update_window_key_event(gpointer data) { AConvert *aconv = (AConvert *)data; aconv->keyboard->win=get_active_window(aconv->keyboard->dpy); if((aconv->keyboard->win == None) || (aconv->keyboard->win == PointerRoot)) return TRUE; WInfo *info = AddWindow(aconv->keyboard->win,aconv); if(info) { switch (get_find_name_to_grab(aconv,info)) { case -1: grab_wind_event(aconv); get_key_win(aconv); break; case 0: grab_wind_event(aconv); get_key_win(aconv); break; case 1: get_key_win(aconv); break; case 2: return TRUE; default: break; } } //get_key_win(aconv); return TRUE; }
/*============================================================================= * MULTI MENU */ static bmenuDECLARE( multi ) { StartF = MENUstart; CheckF = MENUcheck; InputF = MENUinput; DisplayF = MENUdraw; Fallback = "main"; for(int i = 0; i < GAME_MAX_BRAINS; i++) { float s = BDEF_BUTTON_H; float y = BMENU_RATIO - .04 -1.1*s*(i+1); boxC* w = AddWindow("Players", "This is the list of players that will take part in the game;" " it also tells you which player has already pressed the" " ?HReady?/ button.", .05, y, 1.5*BDEF_BUTTON_W, s, 0, mmuDisplayPlayer); w->Id = i; } AddButton("Ready", "When all the players in the list press this button, the game starts" " and no one else can join anymore.\n", .7, .05, BDEF_BUTTON_W, BDEF_BUTTON_H, 'r', btf_ready); } bmenuINSTANCE;
boost::optional<boost::shared_ptr<Error> > TitleScene::SceneInitialize(void) { next_scene.reset(); OPT_ERROR(AddWindow(script_window, 0, 0, 0, 0)); boost::shared_ptr<const std::wstring> image_filename(new std::wstring(L"data/scene/title.png")); OPT_ERROR(AddImageUI(image_filename, uis::UIBase::MOVE_MODE_CENTER_FREE, 0, 50)); std::vector<boost::tuple<boost::shared_ptr<const std::wstring>, boost::shared_ptr<void> > > ui_list; const wchar_t *text_list[] = { L"NewGame", L"LoadGame", L"Exit" }; boost::shared_ptr<void> next_list[] = { boost::shared_ptr<void>(new NEXT(NEXT_NEW_GAME)), boost::shared_ptr<void>(new NEXT(NEXT_LOAD_GAME)), boost::shared_ptr<void>(new NEXT(NEXT_EXIT)) }; for(unsigned int i = 0; i < 3; i++) { boost::shared_ptr<const std::wstring> text(new std::wstring(text_list[i])); boost::shared_ptr<void> next(next_list[i]); ui_list.push_back(make_tuple(text, next)); } OPT_ERROR(AddSelectorWindow(ui_list, 1, boost::none, 250, 300, 140, 80)); return boost::none; }
/* ================ rvGENavigator::AddWindow Adds a new window to the navigator ================ */ void rvGENavigator::AddWindow( idWindow *window ) { int index; LVITEM item; rvGEWindowWrapper *wrapper; wrapper = rvGEWindowWrapper::GetWrapper( window ); // Dont add deleted windows if( !wrapper || wrapper->IsDeleted( ) ) { return; } // Insert the window into the tree ZeroMemory( &item, sizeof( item ) ); item.mask = LVIF_PARAM | LVIF_STATE | LVIF_IMAGE; item.iItem = ListView_GetItemCount( mTree ); item.lParam = ( LONG ) window; item.iImage = 0; item.state = rvGEWindowWrapper::GetWrapper( window )->IsSelected() ? LVIS_SELECTED : 0; item.stateMask = LVIS_SELECTED; ListView_InsertItem( mTree, &item ); if( item.state & LVIS_SELECTED ) { ListView_EnsureVisible( mTree, item.iItem, false ); } // Dont continue if not expanded. if( !wrapper->IsExpanded( ) ) { return; } // Insert all the child windows into the tree for( index = 0; index < wrapper->GetChildCount(); index ++ ) { AddWindow( wrapper->GetChild( index ) ); } }
EventLoop::EventLoop(const vector<shared_ptr<Window>> &wins, const vector<shared_ptr<Menu>> &ms){ for(auto w : wins){ AddWindow(w); } for(auto m : ms){ AddMenu(m); } }
uint8_t CManagerWindow::CreateNewWindow( SDL_Rect& size, std::string& text, SDL_Color* bkgnd_color, CGraphic* bkgnd_image ) { // Create the window CWindow* window = new CWindow( size, mEvents, text, bkgnd_color, bkgnd_image ); return AddWindow( window ); }
void TWindow::Create() { ASSERT(!IsCreated()); if (!IsCreated()) { int screen = gApplication->GetDefaultScreen(); Window parent = (fParent ? fParent->GetXWindow() : RootWindow(sDisplay, screen)); XSetWindowAttributes attributes; unsigned long attributesMask = CWBackPixel; int border = fBorder; attributes.background_pixel = fBackColor.GetPixel(); if (fStyle == kPopupWindow) { attributes.save_under = true; attributes.override_redirect = true; attributesMask |= CWSaveUnder; attributesMask |= CWOverrideRedirect; border = 1; } fWindow = XCreateWindow(sDisplay, parent, fBounds.left, fBounds.top, GetWidth(), GetHeight(), border, CopyFromParent, InputOutput, CopyFromParent, attributesMask, &attributes); XSelectInput(sDisplay, fWindow, ExposureMask|FocusChangeMask| KeyPressMask|KeyReleaseMask| ButtonPressMask|ButtonReleaseMask| EnterWindowMask|LeaveWindowMask|PointerMotionMask| StructureNotifyMask | VisibilityChangeMask /*|SubstructureNotifyMask*/ ); XWindowAttributes attr; XGetWindowAttributes(sDisplay, fWindow, &attr); fDepth = attr.depth; if (fStyle == kTopLevelWindow) { Atom atoms[2] = { sDeleteWindowAtom, sTakeFocusAtom }; //ignore take focus? XSetWMProtocols(sDisplay, fWindow, atoms, 2); XSetWMProtocols(sDisplay, fWindow, atoms, 1); } AddWindow(this); // give the positioner a chance to do its thing // if (fParent && fPositioner) // fPositioner(this, fParent->fBounds, fParent->fBounds); SetCursor(sDefaultCursor); TListIterator<TWindow> iter(fChildren); TWindow* child; while ((child = iter.Next()) != NULL) child->Create(); } }
boost::optional<boost::shared_ptr<Error> > CastleScene::SceneInitialize(void) { OPT_ERROR(CampScene::SceneInitialize()); next_scene.reset(); OPT_ERROR(AddWindow(script_window, 0, 0, 0, 0)); OPT_ERROR(AddBoxUI(uis::UIBase::MOVE_MODE_FREE_FREE, 10, 25, 620, 445)); OPT_ERROR(AddTextUI(title, uis::UIBase::MOVE_MODE_CENTER_FREE, 262, 9, 116, 32)); OPT_ERROR(AddPTStatusUI(pt, uis::UIBase::MOVE_MODE_FREE_FREE, 0, 350, DEFAULT_SCREEN_SIZE_X, 130)); return StepInitialize(); }
void CreateIconManagers() { IconMgr *p; int mask; char str[100]; char str1[100]; Pixel background; char *icon_name; if (Scr->NoIconManagers) return; if (Scr->siconifyPm == None) { Scr->siconifyPm = XCreatePixmapFromBitmapData(dpy, Scr->Root, (char *)siconify_bits, siconify_width, siconify_height, 1, 0, 1); } for (p = &Scr->iconmgr; p != NULL; p = p->next) { mask = XParseGeometry(p->geometry, &JunkX, &JunkY, (unsigned int *) &p->width, (unsigned int *)&p->height); if (mask & XNegative) JunkX = Scr->MyDisplayWidth - p->width - (2 * Scr->BorderWidth) + JunkX; if (mask & YNegative) JunkY = Scr->MyDisplayHeight - p->height - (2 * Scr->BorderWidth) + JunkY; background = Scr->IconManagerC.back; GetColorFromList(Scr->IconManagerBL, p->name, (XClassHint *)NULL, &background); p->w = XCreateSimpleWindow(dpy, Scr->Root, JunkX, JunkY, p->width, p->height, 1, Scr->Black, background); sprintf(str, "%s Icon Manager", p->name); sprintf(str1, "%s Icons", p->name); if (p->icon_name) icon_name = p->icon_name; else icon_name = str1; XSetStandardProperties(dpy, p->w, str, icon_name, None, NULL, 0, NULL); p->twm_win = AddWindow(p->w, TRUE, p); SetMapStateProp (p->twm_win, WithdrawnState); } for (p = &Scr->iconmgr; p != NULL; p = p->next) { GrabButtons(p->twm_win); GrabKeys(p->twm_win); } }
int main(int argc, char *argv[]) { const char *dpyName = XDisplayName(NULL); struct window *h0, *h1, *h2, *h3; /* four windows and contexts sharing display lists and texture objects */ h0 = AddWindow(dpyName, 10, 10, NULL); h1 = AddWindow(dpyName, 330, 10, h0); h2 = AddWindow(dpyName, 10, 350, h0); h3 = AddWindow(dpyName, 330, 350, h0); InitGLstuff(h0); EventLoop(); return 0; }
TextBox::TextBox(std::string text, SDL_Rect location, Renderer *renderer) { SetLocation(location); SDL_Color color = { 160, 160, 160, 255}; SetTexture(TextureFactory::CreateWindowTexture(location.w, location.h, color, renderer)); std::unique_ptr<TextField> element(new TextField(text, 13, location, renderer)); AddWindow(std::move(element)); }
int main(int argc, char *argv[]) { const char *dpyName = XDisplayName(NULL); pthread_t t0, t1, t2, t3; struct thread_init_arg tia0, tia1, tia2, tia3; struct window *h0; XInitThreads(); gDpy = XOpenDisplay(dpyName); if (!gDpy) { Error(dpyName, "Unable to open display"); return -1; } if (initMainthread(gDpy, dpyName)) return -1; /* four windows and contexts sharing display lists and texture objects */ h0 = AddWindow(gDpy, dpyName, 10, 10, gCtx); (void) AddWindow(gDpy, dpyName, 330, 10, gCtx); (void) AddWindow(gDpy, dpyName, 10, 350, gCtx); (void) AddWindow(gDpy, dpyName, 330, 350, gCtx); if (!glXMakeCurrent(gDpy, h0->Win, gCtx)) { Error(dpyName, "glXMakeCurrent failed for init thread."); return -1; } InitGLstuff(); tia0.id = 0; pthread_create(&t0, NULL, threadRunner, &tia0); tia1.id = 1; pthread_create(&t1, NULL, threadRunner, &tia1); tia2.id = 2; pthread_create(&t2, NULL, threadRunner, &tia2); tia3.id = 3; pthread_create(&t3, NULL, threadRunner, &tia3); EventLoop(); return 0; }
// warning: initialization of item is incomplete! // initialization of item's height, text static and icon still necessary CUIPdaMsgListItem* CUIGameLog::AddPdaMessage(LPCSTR msg, float delay){ CUIPdaMsgListItem* pItem = xr_new<CUIPdaMsgListItem>(); pItem->Init (0,0, GetDesiredChildWidth(), 10); //fake height pItem->UIMsgText.SetTextST (msg); pItem->SetClrAnimDelay (delay); pItem->SetClrLightAnim (CHAT_LOG_ITEMS_ANIMATION, false, true, true, true); AddWindow (pItem, true); return pItem; }
void LoadAllWindowPlacements() { std::vector<HWND> handles; EnumWindows(EnumWindowsProc, (LPARAM)&handles); for(HWND hWnd : handles) { if(IsApplicationWindow(hWnd)) AddWindow(hWnd); } }
CUIPdaKillMessage* CUIGameLog::AddLogMessage(KillMessageStruct& msg){ CUIPdaKillMessage* pItem = pItem = xr_new<CUIPdaKillMessage>(); pItem->SetFont(GetFont()); pItem->SetWidth(GetDesiredChildWidth()); pItem->SetHeight(kill_msg_height); pItem->Init(msg); pItem->SetClrAnimDelay(5000.0f); pItem->SetClrLightAnim(CHAT_LOG_ITEMS_ANIMATION, false, true, true, true); AddWindow(pItem, true); return pItem; }
void createWindowBoxes(void) { WindowBox *winbox; char title [128]; XWMHints wmhints; XSizeHints sizehints; for(winbox = Scr->FirstWindowBox; winbox; winbox = winbox->next) { int mask, x, y, gravity; unsigned int w, h; Window win; mask = XParseGeometry(winbox->geometry, &x, &y, &w, &h); if(mask & XNegative) { x += Scr->rootw - w; gravity = (mask & YNegative) ? SouthEastGravity : NorthEastGravity; } else { gravity = (mask & YNegative) ? SouthWestGravity : NorthWestGravity; } if(mask & YNegative) { y += Scr->rooth - h; } win = XCreateSimpleWindow(dpy, Scr->Root, x, y, w, h, 0, Scr->Black, Scr->White); /*printf ("createWindowBoxes : name = %s, win = 0x%x, x = %d, y = %d, w = %d, h = %d\n", winbox->name, win, x, y, w, h); */ sprintf(title, "%s", winbox->name); XSetStandardProperties(dpy, win, title, title, None, NULL, 0, NULL); sizehints.flags = USPosition | USSize | PWinGravity; sizehints.x = x; sizehints.y = y; sizehints.width = w; sizehints.height = h; sizehints.win_gravity = gravity; XSetWMSizeHints(dpy, win, &sizehints, XA_WM_NORMAL_HINTS); wmhints.initial_state = NormalState; wmhints.input = True; wmhints.flags = InputHint | StateHint; XSetWMHints(dpy, win, &wmhints); winbox->window = win; winbox->twmwin = AddWindow(win, ADD_WINDOW_WINDOWBOX, NULL, Scr->currentvs); if(!winbox->twmwin) { fprintf(stderr, "cannot create %s window box, exiting...\n", winbox->name); exit(1); } winbox->twmwin->iswinbox = TRUE; XMapWindow(dpy, win); } }
bool BedWindow::FindOneOrMoreWindowOverlaps(const BED &a) { // update the current feature's start and end // according to the slop requested (slop = 0 by default) CHRPOS aFudgeStart = 0; CHRPOS aFudgeEnd; AddWindow(a, aFudgeStart, aFudgeEnd); bool overlapsFound = _bedB->anyHits(a.chrom, a.start, a.end, a.strand, _matchOnSameStrand, _matchOnDiffStrand, 0.0, false); return overlapsFound; }
/* ================ rvGENavigator::Update Updates the contents of the navigator window from the current workspace ================ */ void rvGENavigator::Update( void ) { // Clear the list first ListView_DeleteAllItems( mTree ); // Add starting with the desktop window if( mWorkspace ) { AddWindow( mWorkspace->GetInterface( )->GetDesktop( ) ); } // For some reason the horizontal scrollbar wants to show up initially after an update // so this forces it not to RECT rClient; GetClientRect( mTree, &rClient ); ListView_SetColumnWidth( mTree, 0, rClient.right - rClient.left - 1 ); }
void BedWindow::FindWindowOverlaps(const BED &a, vector<BED> &hits) { /* Adjust the start and end of a based on the requested window */ // update the current feature's start and end // according to the slop requested (slop = 0 by default) CHRPOS aFudgeStart = 0; CHRPOS aFudgeEnd; AddWindow(a, aFudgeStart, aFudgeEnd); /* Now report the hits (if any) based on the window around a. */ // get the hits in B for the A feature _bedB->allHits(a.chrom, aFudgeStart, aFudgeEnd, a.strand, hits, _matchOnSameStrand, _matchOnDiffStrand, 0.0, false); int numOverlaps = 0; // loop through the hits and report those that meet the user's criteria vector<BED>::const_iterator h = hits.begin(); vector<BED>::const_iterator hitsEnd = hits.end(); for (; h != hitsEnd; ++h) { int s = max(aFudgeStart, h->start); int e = min(aFudgeEnd, h->end); int overlapBases = (e - s); // the number of overlapping bases b/w a and b int aLength = (a.end - a.start); // the length of a in b.p. if (s < e) { // is there enough overlap (default ~ 1bp) if ( ((float) overlapBases / (float) aLength) > 0 ) { numOverlaps++; if (_anyHit == false && _noHit == false && _writeCount == false) { _bedA->reportBedTab(a); _bedB->reportBedNewLine(*h); } } } } if (_anyHit == true && (numOverlaps >= 1)) { _bedA->reportBedNewLine(a); } else if (_writeCount == true) { _bedA->reportBedTab(a); printf("%d\n", numOverlaps); } else if (_noHit == true && (numOverlaps == 0)) { _bedA->reportBedNewLine(a); } }
void CUIListBox::AddExistingItem(CUIListBoxItem* item) { item->InitFrameLineWnd (Fvector2().set(0,0), Fvector2().set(GetDesiredChildWidth()-5, m_def_item_height)); item->SetWidth (GetDesiredChildWidth()); if(m_selection_texture.size()) item->InitTexture (m_selection_texture.c_str(), "hud\\default"); else item->InitDefault (); item->SetSelected (false); item->SetMessageTarget (this); AddWindow (item, true); }
DWORD WINAPI HandleClients(LPVOID cl) { SOCKET Client; Client = ((SOCKET *) cl)[0]; cString string; string.PutString(Client,"Welcome to your Smart-House Manager!\n>"); while (string.ReadLine("", Client) && string != "exit") { if (string == "add house") { AddHouse(Client); } else if (string == "delete house") { DelHouse(Client); } else if (string == "print") { Print(Client); } else if (string == "add floor") { AddFloor(Client); } else if (string == "add room") { AddRoom(Client); } else if (string == "help") { PrintHelp(Client); } else if (string == "add window") { AddWindow(Client); } else { string.PutString(Client,"You've entered unknown command \n>"); break; } string.PutString(Client, ""); } return 0; }
// _____________________________________________________________________ // // // Global event listener // _____________________________________________________________________ // void CALLBACK WinEventProc(HWINEVENTHOOK hWinEventHook, DWORD event, HWND hwnd, LONG idObject, LONG idChild, DWORD dwEventThread, DWORD dwmsEventTime) { if(IsPaused) return; switch(event) { case EVENT_OBJECT_LOCATIONCHANGE: if(!idObject && HasWindow(hwnd)) ScheduleWindowPlacementUpdate(hwnd); break; case EVENT_OBJECT_CREATE: case EVENT_OBJECT_SHOW: if(!HasWindow(hwnd) && IsApplicationWindow(hwnd)) AddWindow(hwnd); break; case EVENT_OBJECT_DESTROY: case EVENT_OBJECT_HIDE: if(!idObject) RemoveWindow(hwnd); break; case EVENT_OBJECT_PARENTCHANGE: if(HasWindow(hwnd)) { if(!IsApplicationWindow(hwnd)) RemoveWindow(hwnd); } else if(IsApplicationWindow(hwnd)) { AddWindow(hwnd); } break; } }
/* Display the submenu pointed to by the passed show: menu item. */ void ShowSubMenu (Menu_Item_Type *i) { int c; Menu_Type *m; /* find matching menu, if any */ if ((m=LookupMenu(i->command)) != NULL) { /* got match -- show it and handle input for it. */ AddWindow(m); DrawAll(); do { c=DoMenu(m,Pdmenu_Action,Handle_Ctrl_C); if ((c==QUIT_EXIT) || (c==Q_KEY_EXIT)) ExitWindow(); } while (c==0); } }
int FreePM_DeskTop::Init(int nx, int ny, int bytesPerPixel) { int i, ordinal,tid,rc, len,inf[2]; /* desktop is a usual application with its HAB, queue and procedure */ /* initialize hab */ ordinal = QueryThreadOrdinal(tid); rc = _shab.QueryOrdinalUsed(ordinal, Q_ORDINAL_HAB); if(rc != -1) { _shab.SetError(rc, PMERR_ALREADY_INITIALIZED); fatalf("FreePM_DeskTop::Init WARNING: Tread Ordinal already used\n"); return NULLHANDLE; } iHab = pSession->hab_list.Add(iClientId,-1); /* Create queue */ _shab.hab[iHab].pQueue = new FreePM_Queue(iHab); pQueue = _shab.hab[iHab].pQueue; debug(8, 0) ("FreePM_DeskTop::Init iHab = %i\n", iHab); /* создание окна HWND_DESKTOP */ /* the creation of window HWND_DESKTOP */ pWindow = new DeskTopWindow(); /* bytesPerPixel */ pWindow->CreateDeskTopWindow(0L,nx, ny, NULL, NULL); /* bytesPerPixel */ hwnd = AddWindow(pWindow); pWindow->SetHandle(hwnd); /* Init device i.e. memory, PM, gradd or else */ rc = pSession->InitDevice(FPM_DEV_PMWIN, this); /*rc = pSession->InitDevice(FPM_DEV_SERVERMEM, this);*/ /* init videomode */ /* Draw a picture in a buffer */ //pBmpBuffer = (PBYTE)this->pVBuffmem; InitBuffer(this->pVBuffmem, nx, ny, bytesPerPixel); debug(8, 0) ("FreePM_DeskTop::Init OK\n"); /* создание остальных окон */ /* the creation of the remaining windows */ //todo // prokushev: I think here we must create separate thread which will // process desktop messages loop. return 0; }
CUIListBoxItem* CUIListBox::AddItem() { CUIListBoxItem* item = xr_new<CUIListBoxItem>(m_def_item_height); item->InitFrameLineWnd (Fvector2().set(0,0), Fvector2().set(GetDesiredChildWidth()-5, m_def_item_height)); item->GetTextItem()->SetWidth (GetDesiredChildWidth()); item->SetWidth (GetDesiredChildWidth()); if(m_selection_texture.size()) item->InitTexture (m_selection_texture.c_str(), "hud\\default"); else item->InitDefault (); item->SetFont (GetFont()); item->SetSelected (false); item->SetMessageTarget (this); AddWindow (item, true); return item; }
void WindowsModel::updateWinList () { auto& w = Util::XWrapper::Instance (); QSet<Window> known; for (const auto& info : Windows_) known << info.WID_; auto current = w.GetWindows (); current.erase (std::remove_if (current.begin (), current.end (), [this, &w] (Window wid) { return !w.ShouldShow (wid); }), current.end ()); for (auto i = current.begin (); i != current.end (); ) { if (known.remove (*i)) i = current.erase (i); else ++i; } for (auto wid : known) { const auto pos = std::find_if (Windows_.begin (), Windows_.end (), [&wid] (const WinInfo& info) { return info.WID_ == wid; }); const auto dist = std::distance (Windows_.begin (), pos); beginRemoveRows ({}, dist, dist); Windows_.erase (pos); endRemoveRows (); ImageProvider_->RemoveIcon (QString::number (wid)); } if (!current.isEmpty ()) { beginInsertRows ({}, Windows_.size (), Windows_.size () + current.size () - 1); for (auto wid : current) AddWindow (wid, w); endInsertRows (); } }
void CUIGameLog::AddChatMessage(LPCSTR msg, LPCSTR author){ string256 fullLine; sprintf_s(fullLine, "%s %s", author, msg); _TrimRight (fullLine); CUIStatic* pItem = NULL; pItem = xr_new<CUIStatic>(); pItem->SetTextComplexMode (true); pItem->SetText(fullLine); pItem->m_pLines->SetCutWordsMode(true); pItem->SetFont(GetFont()); pItem->SetTextColor(txt_color); pItem->SetClrAnimDelay(5000.0f); pItem->SetClrLightAnim(CHAT_LOG_ITEMS_ANIMATION, false, true, true, true); pItem->SetWidth(this->GetDesiredChildWidth()); pItem->AdjustHeightToText(); AddWindow(pItem, true); }
void CDBPickView::Run() { ClearWaveformInfo(); nLastMarkRightPos=0; int nElem=this->pRTDisplay->WaveformInfo.GetSize(); for(int i=0; i<nElem; ++i) { CMWindow *pMWin=pRTDisplay->WaveformInfo[i]; CString sSta=pMWin->StaName; CString sChan=pMWin->ChanName; double dSpS=pMWin->dSpS; AddWindow(sSta, sChan,dSpS); } t1=this->pRTDisplay->t1; t2=this->pRTDisplay->t2; nActiveScreen=0; CalculateWindowsSize(); DrawWaveforms(); }
CUIListBoxItem* CUIListBox::AddItem(LPCSTR text) { if (!text) return NULL; CUIListBoxItem* pItem = new CUIListBoxItem(); pItem->InitFrameLineWnd (Fvector2().set(0,0), Fvector2().set(this->GetDesiredChildWidth()-5, m_def_item_height) ); if (!m_selection_texture) pItem->InitDefault (); else pItem->InitTexture (*m_selection_texture,"hud\\default"); pItem->SetSelected (false); pItem->m_text.SetText (*CStringTable().translate(text)); pItem->SetTextColor (m_text_color, m_text_color_s); pItem->SetMessageTarget (this); AddWindow (pItem, true); return pItem; }