header *create_environ_header(char *name,char *value){ if(value==NULL){ return create_header(name,""); } else{ return create_header(name,value); } }
void create_about_gui(Sven *sven,GtkWidget *vbox1) { GtkWidget *vbox; GtkWidget *notebook; GdkColor color; DEBUG_MSG("Start create_about_gui\n"); gtk_box_pack_start (GTK_BOX (vbox1), create_header(_("Info")), FALSE, FALSE, 0); vbox =gtk_vbox_new (FALSE, BORDER); gtk_container_set_border_width (GTK_CONTAINER (vbox), BORDER); gtk_widget_show (vbox); gtk_box_pack_start (GTK_BOX (vbox1), vbox, TRUE, TRUE, 0); /* the notebook */ notebook = gtk_notebook_new (); gtk_widget_show (notebook); gtk_widget_set_size_request (notebook, -1, 300); gtk_box_pack_start (GTK_BOX (vbox), notebook, TRUE, TRUE, 0); /* add pages */ add_page (GTK_NOTEBOOK (notebook), _("Info"), INFO, FALSE); add_page (GTK_NOTEBOOK (notebook), _("Authors"), AUTHORS, FALSE); add_page (GTK_NOTEBOOK (notebook), _("Thanks To"), THANKS, TRUE); add_page (GTK_NOTEBOOK (notebook), _("Translators"), TRANSLATORS, TRUE); gtk_widget_show_all(vbox); }
void display(struct tree_node* root) { struct tree_node* temp; int i=1; printf("Level 0 : %d\n",root->data); if(((root->lson)==NULL)&&((root->rson)==NULL)) { return; } struct node* head=create_header(); push(head,root); while(head->next!=NULL) { temp=pop(head); if(temp->lson!=NULL) { push(head,temp->lson); } if(temp->rson!=NULL) { push(head,temp->rson); } if(temp->lson!=NULL) printf("level %d :%d",i,temp->lson->data); if(temp->rson!=NULL) printf("level %d :%d",i,temp->rson->data); i++; printf("\n"); } free(head); }
struct tree_node* find_node(struct tree_node* root,int data) { struct tree_node* temp;/// if(root->data==data) { return (root); } if(((root->lson)==NULL)&&((root->rson)==NULL)) { return (NULL); } struct node* head=create_header(); push(head,root); while(head->next!=NULL) { temp=pop(head); if(temp->data==data) { return (temp); } if(temp->lson!=NULL) { push(head,temp->lson); } if(temp->rson!=NULL) { push(head,temp->rson); } } free(head); return(NULL); }
bool elfio::load( std::istream &stream ) { clean(); unsigned char e_ident[EI_NIDENT]; // Read ELF file signature stream.seekg( 0 ); stream.read( reinterpret_cast<char*>( &e_ident ), sizeof( e_ident ) ); // Is it ELF file? if ( stream.gcount() != sizeof( e_ident ) || e_ident[EI_MAG0] != ELFMAG0 || e_ident[EI_MAG1] != ELFMAG1 || e_ident[EI_MAG2] != ELFMAG2 || e_ident[EI_MAG3] != ELFMAG3 ) { return false; } if ( ( e_ident[EI_CLASS] != ELFCLASS64 ) && ( e_ident[EI_CLASS] != ELFCLASS32 )) { return false; } convertor.setup( e_ident[EI_DATA] ); header = create_header( e_ident[EI_CLASS], e_ident[EI_DATA] ); if ( 0 == header ) { return false; } if ( !header->load( stream ) ) { return false; } load_sections( stream ); load_segments( stream ); return true; }
int test_write_header() { struct setec_astronomy_header w_header, r_header; char temp_file[] = TEST_DATA_DIR "temp"; init_header(&w_header); init_header(&r_header); create_header(&w_header, DEFAULT_IV_LEN, DEFAULT_SALT_LEN, DEFAULT_HASH_COUNT, DEFAULT_PASSWORD, DEFAULT_HASH_LEN); test_equals(write_header(&w_header, temp_file), SA_SUCCESS); test_equals(read_header(&r_header, temp_file), SA_SUCCESS); test_equals(w_header.salt_len, r_header.salt_len); test_equals(w_header.hash_count, r_header.hash_count); test_equals(w_header.hash_len, w_header.hash_len); test_equals(w_header.iv_len, r_header.iv_len); test_equals(strncmp(w_header.salt, r_header.salt, w_header.salt_len), 0); test_equals(strncmp(w_header.hash, r_header.hash, w_header.hash_len), 0); test_equals(strncmp(w_header.iv, r_header.iv, w_header.iv_len), 0); test_equals(strncmp(w_header.hash, r_header.hash, w_header.hash_len), 0); free_header(&w_header); free_header(&r_header); return 0; }
void create_archive_file(std::vector<fs::path> const& files, std::string const& archive_name) { using size_type = std::vector<fs::path>::size_type; auto const file_sizes = enumerate_file_sizes(files); std::ofstream archive{archive_name, std::ofstream::binary}; create_body(files, file_sizes, archive); create_header(files, file_sizes, archive); }
lfl_string as_loadvars::create_request(const lfl_string& method, const lfl_string& uri, bool send_data) { lfl_string information; //create information in the form of name=value (urlencoded) string_hash<lfl_string>::iterator it = m_values.begin(); for(bool first = true; it != m_values.end(); ++it) { lfl_string name, value; name = it->first; value = it->second; url_encode( &name ); url_encode( &value ); information += string_printf("%s%s=%s", first? "":"&",name.c_str(), value.c_str() ); first = false; } if( method == "POST") { lfl_string request = string_printf( "POST %s HTTP/1.1\r\n", uri.c_str() ); m_headers.set("Content-Length", string_printf( "%i", information.size())); request += create_header(); request += "\r\n"; request += information; return request; } else if(method == "GET") { lfl_string request = string_printf( "GET %s?%s HTTP/1.1\r\n", uri.c_str(), information.c_str() ); request += create_header(); request += "\r\n"; return request; } else { assert(0 && "unsupported"); } return ""; }
void connection::read_directory(net::connection_info & CI) { namespace fs = boost::filesystem; std::stringstream ss; ss << "<head>\n" "</head>\n" "<body bgcolor=\"#111111\" text=\"#D8D8D8\" link=\"#FF8C00\" vlink=\"#FF8C00\">\n" "<table>\n" "<tr>\n" "<td>name</td>\n" "<td>size</td>\n" "</tr>\n"; try{ std::map<std::string, std::string> directory; std::map<std::string, std::string> file; for(fs::directory_iterator it_cur(path), it_end; it_cur != it_end; ++it_cur){ std::string relative_path = it_cur->path().directory_string().substr(web_root.size()); encode_chars(relative_path); std::string file_name = it_cur->path().filename(); std::stringstream tmp_ss; if(fs::is_directory(it_cur->path())){ tmp_ss << "<tr>\n<td>\n<a href=\"" << relative_path << "\">" << file_name << "/</a>\n</td>\n<td>DIR</td>\n</tr>"; boost::to_upper(file_name); directory.insert(std::make_pair(file_name, tmp_ss.str())); }else{ tmp_ss << "<tr>\n<td>\n<a href=\"" << relative_path << "\">" << it_cur->path().filename() << "</a>\n</td>\n<td>" << convert::bytes_to_SI(fs::file_size(it_cur->path())) << "</td>\n</tr>\n"; boost::to_upper(file_name); file.insert(std::make_pair(file_name, tmp_ss.str())); } } //append sorted listing to ss for(std::map<std::string, std::string>::iterator it_cur = directory.begin(), it_end = directory.end(); it_cur != it_end; ++it_cur) { ss << it_cur->second; } for(std::map<std::string, std::string>::iterator it_cur = file.begin(), it_end = file.end(); it_cur != it_end; ++it_cur) { ss << it_cur->second; } }catch(std::exception & ex){ LOG << ex.what(); Proactor.disconnect(CI.connection_ID); return; } ss << "</table>\n</body>\n"; std::string header = create_header(ss.str().size()); net::buffer B; B.append(header).append(ss.str()); Proactor.send(CI.connection_ID, B); Proactor.disconnect_on_empty(CI.connection_ID); }
static GtkWidget * populate_menu_from_directory (GtkWidget *menu, MateMenuTreeDirectory *directory) { GList *children; GSList *l; GSList *items; gboolean add_separator; children = gtk_container_get_children (GTK_CONTAINER (menu)); add_separator = (children != NULL); g_list_free (children); items = matemenu_tree_directory_get_contents (directory); for (l = items; l; l = l->next) { MateMenuTreeItem *item = l->data; if (add_separator || matemenu_tree_item_get_type (item) == MATEMENU_TREE_ITEM_SEPARATOR) { add_menu_separator (menu); add_separator = FALSE; } switch (matemenu_tree_item_get_type (item)) { case MATEMENU_TREE_ITEM_DIRECTORY: create_submenu (menu, MATEMENU_TREE_DIRECTORY (item), NULL); break; case MATEMENU_TREE_ITEM_ENTRY: create_menuitem (menu, MATEMENU_TREE_ENTRY (item), NULL); break; case MATEMENU_TREE_ITEM_SEPARATOR : /* already added */ break; case MATEMENU_TREE_ITEM_ALIAS: create_menuitem_from_alias (menu, MATEMENU_TREE_ALIAS (item)); break; case MATEMENU_TREE_ITEM_HEADER: create_header (menu, MATEMENU_TREE_HEADER (item)); break; default: break; } matemenu_tree_item_unref (item); } g_slist_free (items); return menu; }
void regen_good_header_data() { struct setec_astronomy_header header; remove(GOOD_HEADER_DATA); create_header(&header, DEFAULT_IV_LEN, DEFAULT_SALT_LEN, DEFAULT_HASH_COUNT, DEFAULT_PASSWORD, DEFAULT_HASH_LEN); write_header(&header, GOOD_HEADER_DATA); free_header(&header); }
void regen_file_exists() { struct setec_astronomy_header header; remove(FILE_EXISTS); create_header(&header, DEFAULT_IV_LEN, DEFAULT_SALT_LEN, DEFAULT_HASH_COUNT, DEFAULT_PASSWORD, DEFAULT_HASH_LEN); write_header(&header, FILE_EXISTS); free_header(&header); }
fcgi_begin_request* create_begin_request(uint16_t request_id, int alive) { fcgi_begin_request *h = (fcgi_begin_request *) emalloc(sizeof(fcgi_begin_request)); h->header = create_header(FCGI_BEGIN_REQUEST, request_id); h->body = ecalloc(1, sizeof(fcgi_begin_request_body)); if (alive == 1) { h->body->flags |= FCGI_KEEP_CONN; } h->body->role_lo = FCGI_RESPONDER; h->header->content_len_lo = sizeof(fcgi_begin_request_body); return h; }
LIBCOUCHSTORE_API couchstore_error_t couchstore_open_db_ex(const char *filename, couchstore_open_flags flags, const couch_file_ops *ops, Db **pDb) { couchstore_error_t errcode = COUCHSTORE_SUCCESS; Db *db; int openflags; /* Sanity check input parameters */ if ((flags & COUCHSTORE_OPEN_FLAG_RDONLY) && (flags & COUCHSTORE_OPEN_FLAG_CREATE)) { return COUCHSTORE_ERROR_INVALID_ARGUMENTS; } if ((db = calloc(1, sizeof(Db))) == NULL) { return COUCHSTORE_ERROR_ALLOC_FAIL; } if (flags & COUCHSTORE_OPEN_FLAG_RDONLY) { openflags = O_RDONLY; } else { openflags = O_RDWR; } if (flags & COUCHSTORE_OPEN_FLAG_CREATE) { openflags |= O_CREAT; } error_pass(tree_file_open(&db->file, filename, openflags, ops)); if ((db->file.pos = db->file.ops->goto_eof(db->file.handle)) == 0) { /* This is an empty file. Create a new fileheader unless the * user wanted a read-only version of the file */ if (flags & COUCHSTORE_OPEN_FLAG_RDONLY) { error_pass(COUCHSTORE_ERROR_NO_HEADER); } else { error_pass(create_header(db)); } } else { error_pass(find_header(db)); } *pDb = db; return COUCHSTORE_SUCCESS; cleanup: couchstore_close_db(db); return errcode; }
static int inotify_new_task(t_task_base *base) { char httpheader[1024] = {0x0}; create_header(httpheader, base); int fd = active_connect(); if (fd < 0) { LOG(vfs_sig_log, LOG_ERROR, "connect err %m\n"); return -1; } return active_send(fd, httpheader); }
int write_dir_header(char *name, int tar, t_count *count) { t_header *header; if ((header = create_header(name)) == NULL) return (1); #ifdef DEBUG printf("%s is a dir\n", name); #endif open_dir(name, tar, count, header); #ifdef DEBUG printf("OPEN DIR OK\n"); #endif free(header); free(name); return (0); }
/* FIXME this expects start and end aligned to 30mins marks do the rounding * here rather than epg-grid? -> yes */ void mex_epg_grid_set_date_time_span (MexEpgGrid *grid, GDateTime *start, GDateTime *end) { MexEpgGridPrivate *priv; g_return_if_fail (MEX_IS_EPG_GRID (grid)); g_return_if_fail (start && end); priv = grid->priv; priv->first_date = g_date_time_ref (start); priv->last_date = g_date_time_ref (end); create_header (grid); clutter_actor_queue_relayout (CLUTTER_ACTOR (grid)); }
//------------------------------------------------------------------------------ bool load( const std::string& file_name ) { clean(); std::ifstream stream; stream.open( file_name.c_str(), std::ios::in | std::ios::binary ); if ( !stream ) { return false; } unsigned char e_ident[EI_NIDENT]; // Read ELF file signature stream.seekg( 0 ); stream.read( reinterpret_cast<char*>( &e_ident ), sizeof( e_ident ) ); // Is it ELF file? if ( stream.gcount() != sizeof( e_ident ) || e_ident[EI_MAG0] != ELFMAG0 || e_ident[EI_MAG1] != ELFMAG1 || e_ident[EI_MAG2] != ELFMAG2 || e_ident[EI_MAG3] != ELFMAG3 ) { return false; } if ( ( e_ident[EI_CLASS] != ELFCLASS64 ) && ( e_ident[EI_CLASS] != ELFCLASS32 )) { return false; } convertor.setup( e_ident[EI_DATA] ); header = create_header( e_ident[EI_CLASS], e_ident[EI_DATA] ); if ( 0 == header ) { return false; } if ( !header->load( stream ) ) { return false; } load_sections( stream ); load_segments( stream ); return true; }
int create_cor(char *file) { int fd; int fdwrite; int error; if ((fd = open(file, O_RDONLY)) == -1) return (-5); if ((fdwrite = open(my_strfusion(take_begin(file, '.'), ".cor"), O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)) == -1) return (-2); if (create_header(fd, fdwrite) == -1) return (-3); if ((error = write_instructions(fd, fdwrite)) != 0) return (error); close(fd); close(fdwrite); return (0); }
void Ebu3264SubtitleFormat::WriteFile(const AssFile *src, wxString const& filename, wxString const& encoding) const { // collect data from user EbuExportSettings export_settings = get_export_config(0); AssFile copy(*src); std::vector<EbuSubtitle> subs_list = convert_subtitles(copy, export_settings); std::vector<BlockTTI> tti = create_blocks(subs_list, export_settings); BlockGSI gsi = create_header(copy, export_settings); BlockTTI &block0 = tti.front(); snprintf(gsi.tcf, 8, "%02u%02u%02u%02u", (unsigned int)block0.tci.h, (unsigned int)block0.tci.m, (unsigned int)block0.tci.s, (unsigned int)block0.tci.f); snprintf(gsi.tnb, 5, "%5u", (unsigned int)tti.size()); snprintf(gsi.tns, 5, "%5u", (unsigned int)subs_list.size()); // write file agi::io::Save f(from_wx(filename), true); f.Get().write((const char *)&gsi, sizeof(gsi)); for (auto const& block : tti) f.Get().write((const char *)&block, sizeof(block)); }
void connection::file_send_call_back(net::connection_info & CI) { net::buffer B; if(index == 0){ //prepare header boost::uint64_t size; try{ size = boost::filesystem::file_size(path); }catch(std::exception & ex){ LOG << ex.what(); CI.send_call_back.clear(); Proactor.disconnect(CI.connection_ID); return; } std::string header = create_header(size); B.append(header); } if(index == 0 || CI.send_buf_size < MTU){ std::fstream fin(path.string().c_str(), std::ios::in | std::ios::binary); if(fin.is_open()){ fin.seekg(index, std::ios::beg); B.tail_reserve(MTU); fin.read(reinterpret_cast<char *>(B.tail_start()), B.tail_size()); B.tail_resize(fin.gcount()); index += fin.gcount(); Proactor.send(CI.connection_ID, B); if(fin.eof()){ CI.send_call_back.clear(); Proactor.disconnect_on_empty(CI.connection_ID); } }else{ CI.send_call_back.clear(); Proactor.disconnect(CI.connection_ID); } } }
// Print (or preview) a single page void CHexEditView::OnPrint(CDC* pDC, CPrintInfo* pInfo) { ASSERT(print_offset_.cx >= 0 && print_offset_.cy >= 0); pDC->SetMapMode(print_map_mode_); int u_scale = pDC->GetDeviceCaps(LOGPIXELSX); // units scaling (pixels/inch) if (theApp.print_units_ == CHexEditApp::PRN_CM) u_scale = int(u_scale/2.54); CRect rct; // Encloses all incl. header/footer - ie nothing is printed outside this box CRect margin_rct; // Smaller box based on margins - does not include header/footer CString ss; // String to display at top of page // Work out text height of the (printer) font pDC->SelectObject(print_font_); TEXTMETRIC tm; pDC->GetTextMetrics(&tm); int text_height = tm.tmHeight + tm.tmExternalLeading; // Work out size of the page int vert_res = pDC->GetDeviceCaps(VERTRES); int horz_res = pDC->GetDeviceCaps(HORZRES); if (vert_res < horz_res/5) // May be lines of text not pixels (Eg Text Only driver) vert_res *= text_height; // xxx should be device units not logical // Work out where the margins are margin_rct.top = LONG(theApp.top_margin_*u_scale); margin_rct.left = LONG(theApp.left_margin_*u_scale); margin_rct.bottom = vert_res - LONG(theApp.bottom_margin_*u_scale); margin_rct.right = horz_res - LONG(theApp.right_margin_*u_scale); pDC->DPtoLP(&margin_rct); // Work out where to print the header and footer rct.top = LONG(theApp.header_edge_*u_scale); rct.left = LONG(theApp.left_margin_*u_scale); rct.bottom = vert_res - LONG(theApp.footer_edge_*u_scale); rct.right = horz_res - LONG(theApp.right_margin_*u_scale); // Note we can't use ConvertFromDP here as this is for printer not screen pDC->DPtoLP(&rct); pDC->SetBkMode(TRANSPARENT); if (theApp.print_watermark_) { // Work out angle of diagonal from bottom left to top right ASSERT(rct.Height() != 0 && rct.Width() != 0); // else we get divide by zero error double diag = (int)sqrt((double)(rct.Height()*rct.Height()) + rct.Width()*rct.Width()); double angle = asin(rct.Height()/diag); // Create a large font at the angle of the diagonal int fangle = int(angle * 1800 / 3.141592 /*M_PI*/); // convert diag angle to tenth of degrees from X-axis CFont fontWatermark; fontWatermark.CreateFont(rct.Height()/10, 0, fangle, fangle, FW_BOLD, 0, 0, 0, ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_SWISS, _T("Arial")); CFont * pSaved = pDC->SelectObject(&fontWatermark); // Create the text CString str = create_header(theApp.watermark_, pInfo->m_nCurPage); // Get length of text then work out how far from the bottom page of the corner should the text start double d = (diag - pDC->GetTextExtent(str).cx)/2; // distance along diag of start of text int x = int(d * cos(angle)); int y = int(d * sin(angle)); pDC->SetTextColor(RGB(208, 208, 208)); // light grey pDC->SetTextAlign(TA_BASELINE); pDC->TextOut(x, rct.Height() - y, str); pDC->SetTextAlign(TA_TOP); (void)pDC->SelectObject(pSaved); fontWatermark.DeleteObject(); } pDC->SetTextColor(RGB(0,0,0)); // Display headers/footers in black int left, mid=1, right; if (theApp.even_reverse_ && pInfo->m_nCurPage%2 == 0) left = 2, right = 0; else left = 0, right = 2; if (rct.top - text_height > margin_rct.top) // Note y values are always -ve down in printer map mode { // Get normal header unless using diff header for 1st page and its the first page CString strHeader; if (theApp.diff_first_header_ && pInfo->m_nCurPage == 1) strHeader = theApp.first_header_; else strHeader = theApp.header_; // Print the 3 parts of the header AfxExtractSubString(ss, strHeader, left, '|'); pDC->DrawText(create_header(ss, pInfo->m_nCurPage), &rct, DT_LEFT | DT_TOP | DT_NOPREFIX | DT_SINGLELINE); AfxExtractSubString(ss, strHeader, mid, '|'); pDC->DrawText(create_header(ss, pInfo->m_nCurPage), &rct, DT_CENTER | DT_TOP | DT_NOPREFIX | DT_SINGLELINE); AfxExtractSubString(ss, strHeader, right, '|'); pDC->DrawText(create_header(ss, pInfo->m_nCurPage), &rct, DT_RIGHT | DT_TOP | DT_NOPREFIX | DT_SINGLELINE); } if (rct.bottom + text_height < margin_rct.bottom) // Note y values are -ve down { // Get normal footer unless using diff footer for 1st page and it's the first page CString strFooter; if (theApp.diff_first_footer_ && pInfo->m_nCurPage == 1) strFooter = theApp.first_footer_; else strFooter = theApp.footer_; // Print the 3 parts of the footer AfxExtractSubString(ss, strFooter, left, '|'); pDC->DrawText(create_header(ss, pInfo->m_nCurPage), &rct, DT_LEFT | DT_BOTTOM | DT_NOPREFIX | DT_SINGLELINE); AfxExtractSubString(ss, strFooter, mid, '|'); pDC->DrawText(create_header(ss, pInfo->m_nCurPage), &rct, DT_CENTER | DT_BOTTOM | DT_NOPREFIX | DT_SINGLELINE); AfxExtractSubString(ss, strFooter, right, '|'); pDC->DrawText(create_header(ss, pInfo->m_nCurPage), &rct, DT_RIGHT | DT_BOTTOM | DT_NOPREFIX | DT_SINGLELINE); } if (theApp.print_hdr_) { // Print column headings rct = margin_rct + CSize(print_offset_.cx, 0); pDC->DrawText("Address", &rct, DT_LEFT | DT_TOP | DT_NOPREFIX | DT_SINGLELINE); for (int ii = 0; ii < rowsize_; ++ii) { char buf[10]; if (!display_.hex_addr) // Probably showing dec addresses and/or line numbers so show dec hdr sprintf(buf, "%2d", ii%100); else if (theApp.hex_ucase_) sprintf(buf, "%02X", ii%0x100); else sprintf(buf, "%02x", ii%0x100); if (!display_.vert_display && display_.hex_area) pDC->TextOut(rct.left + hex_pos(ii, print_text_width_), rct.top, buf, 2); if (display_.vert_display || display_.char_area) pDC->TextOut(rct.left + char_pos(ii, print_text_width_, print_text_width_w_), rct.top, buf+1, 1); } } // Draw margins in print preview if (pInfo != NULL && pInfo->m_bPreview && pDC->m_hAttribDC != NULL) { CPen pen(PS_DOT, 0, RGB(0,0,0)); CPen* ppen = pDC->SelectObject(&pen); pDC->MoveTo(-30000, margin_rct.top); pDC->LineTo(30000, margin_rct.top); pDC->MoveTo(margin_rct.left, -30000); pDC->LineTo(margin_rct.left, 30000); pDC->MoveTo(-30000, margin_rct.bottom); pDC->LineTo(30000, margin_rct.bottom); pDC->MoveTo(margin_rct.right, -30000); pDC->LineTo(margin_rct.right, 30000); pDC->SelectObject(ppen); } if (theApp.print_box_) { // Work out width of total printed text CSize size; rct = margin_rct + CSize(print_offset_.cx, 0); if (display_.char_area) size.cx = char_pos(rowsize_, print_text_width_, print_text_width_w_); else size.cx = hex_pos(rowsize_, print_text_width_); size.cy = 0; // Draw a box around it CPen pen(PS_SOLID, 0, RGB(0,0,0)); CPen* ppen = pDC->SelectObject(&pen); pDC->MoveTo(rct.left - print_text_width_, rct.top); pDC->LineTo(rct.left + size.cx + print_text_width_, rct.top); pDC->LineTo(rct.left + size.cx + print_text_width_, rct.bottom); pDC->LineTo(rct.left - print_text_width_, rct.bottom); pDC->LineTo(rct.left - print_text_width_, rct.top); #if 0 // Draw line between address and hex areas size.cx = hex_pos(0, print_text_width_); size.cy = 0; pDC->MoveTo(rct.left + size.cx - print_text_width_, rct.top); pDC->LineTo(rct.left + size.cx - print_text_width_, rct.bottom); // Draw line between areas if (display_.hex_area && display_.char_area) { size.cx = hex_pos(rowsize_, print_text_width_); size.cy = 0; pDC->MoveTo(rct.left + size.cx - print_text_width_/2, rct.top); pDC->LineTo(rct.left + size.cx - print_text_width_/2, rct.bottom); } #endif pDC->SelectObject(ppen); } // Do this last so pen changes etc do not affect header, footer etc drawing CScrView::OnPrint(pDC, pInfo); // Calls OnDraw to print rest of page }
int tool_app_t::execute() { tool_app_t opts; /* make SIGFPE actually deliver signals on supoorted platforms */ plib::fpsignalenabler::global_enable(true); plib::fpsignalenabler sigen(plib::FP_ALL & ~plib::FP_INEXACT & ~plib::FP_UNDERFLOW); if (opt_help()) { pout(usage()); return 0; } if (opt_version()) { pout( "nltool (netlist) " PSTRINGIFY(NLTOOL_VERSION) "\n" "Copyright (C) 2019 Couriersud\n" "License GPLv2+: GNU GPL version 2 or later <http://gnu.org/licenses/gpl.html>.\n" "This is free software: you are free to change and redistribute it.\n" "There is NO WARRANTY, to the extent permitted by law.\n\n" "Written by Couriersud.\n"); if (opt_verb()) { std::vector<std::pair<pstring, pstring>> defs; netlist::netlist_state_t::compile_defines(defs); pout("\nCompile defines:\n"); for (auto &x : defs) pout("{1:-30} = {2}\n", x.first, x.second); } return 0; } m_options = opt_defines(); m_options.emplace_back("NLTOOL_VERSION=" PSTRINGIFY(NLTOOL_VERSION)); try { pstring cmd = opt_cmd.as_string(); if (cmd == "listdevices") listdevices(); else if (cmd == "run") run(); else if (cmd == "validate") validate(); else if (cmd == "static") static_compile(); else if (cmd == "header") create_header(); else if (cmd == "docheader") create_docheader(); else if (cmd == "convert") convert(); else { perr("Unknown command {}\n", cmd.c_str()); //FIXME: usage_short perr(usage()); return 1; } } catch (netlist::nl_exception &e) { perr("Netlist exception caught: {}\n", e.text()); return 2; } catch (plib::pexception &e) { perr("plib exception caught: {}\n", e.text()); return 2; } return 0; }
std::string Client::get_header() const { return create_header("clnt", 2 + (its_ip.is_v4() ? 4 : 16) + its_name.length()); }
void elfio::create( unsigned char file_class, unsigned char encoding ) { clean(); convertor.setup( encoding ); header = create_header( file_class, encoding ); create_mandatory_sections(); }
std::string Acknowledged::get_header() const { return create_header("ackn", 0); }
void create_xosd_gui(Sven *sven,GtkWidget *vbox) { GtkWidget *hbox,*hbox1, *label,*unit_label,*button1; GtkWidget *table, **position_icons, *position_table,*sep,*button; GdkColor *colors; gint n_colors; Gtk_Osd_Pos curr_pos; Gtk_Osd_Align curr_align; GSList *group = NULL; gtk_box_pack_start (GTK_BOX (vbox),(gpointer )create_header(_("XOSD")), FALSE, FALSE, 0); table = gtk_table_new (7,2, FALSE); gtk_table_set_row_spacings (GTK_TABLE (table), 12); gtk_table_set_col_spacings (GTK_TABLE (table), 12); gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0); // Font selector. label = gtk_label_new (_("Font:")); gtk_misc_set_alignment (GTK_MISC (label), 1.0,0.5); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0); if(sven->osd->font!=NULL) font_entry = gtk_font_button_new_with_font (sven->osd->font); else font_entry = gtk_font_button_new_with_font ("Sans 18"); gtk_table_attach (GTK_TABLE (table), font_entry, 1, 2, 0, 1, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0); //Colour Selector label = gtk_label_new (_("Colour:")); gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0); gtk_color_selection_palette_from_string (sven->osd->color,&colors,&n_colors); colour_entry = gtk_color_button_new_with_color (colors); gtk_table_attach (GTK_TABLE (table), colour_entry, 1, 2, 1, 2, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0); //Timeout label = gtk_label_new (_("Timeout:")); gtk_misc_set_alignment (GTK_MISC (label), 1.0,0.5); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3, GTK_FILL, GTK_FILL, 0, 0); hbox = gtk_hbox_new (FALSE, 6); gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 2, 3, GTK_FILL, GTK_FILL, 0, 0); timeout_obj = gtk_adjustment_new (sven->osd->timeout, -1, 60, 1, 1, 1); timeout_spin = gtk_spin_button_new (GTK_ADJUSTMENT (timeout_obj), 1.0, 0); gtk_spin_button_set_value (GTK_SPIN_BUTTON (timeout_spin), (gfloat) sven->osd->timeout); gtk_box_pack_start (GTK_BOX (hbox), timeout_spin, FALSE, FALSE, 0); unit_label = gtk_label_new (_("seconds")); gtk_misc_set_alignment (GTK_MISC (unit_label),0.0, 0.0); gtk_label_set_justify (GTK_LABEL (unit_label), GTK_JUSTIFY_LEFT); gtk_box_pack_start (GTK_BOX (hbox), unit_label, FALSE, FALSE, 0); // Position label = gtk_label_new (_("Position:")); gtk_misc_set_alignment (GTK_MISC (label), 1.0,0.5); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3,4,GTK_FILL, GTK_FILL, 0, 0); position_icons = position_icons_new (); position_table = gtk_table_new (3, 3, FALSE); gtk_table_set_row_spacings (GTK_TABLE (position_table), 6); gtk_table_set_col_spacings (GTK_TABLE (position_table), 6); gtk_table_attach (GTK_TABLE (table), position_table, 1, 2, 3,4,GTK_FILL, GTK_FILL, 0, 0); curr_pos = GTK_OSD_TOP; for (curr_align = GTK_OSD_LEFT; curr_align <= GTK_OSD_RIGHT; curr_align++) { positions[curr_pos][curr_align] = gtk_radio_button_new (group); gtk_container_add (GTK_CONTAINER (positions[curr_pos][curr_align]),position_icons[(curr_pos * 3) + curr_align]); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON(positions[curr_pos][curr_align]), FALSE); group =gtk_radio_button_group (GTK_RADIO_BUTTON(positions[curr_pos][curr_align])); if (sven->osd->pos == curr_pos && sven->osd->align == curr_align) { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(positions[curr_pos][curr_align]),TRUE); } gtk_table_attach (GTK_TABLE (position_table),positions[curr_pos][curr_align],curr_align, curr_align + 1,curr_pos, curr_pos + 1, GTK_FILL, GTK_FILL, 0, 0); } curr_pos = GTK_OSD_MIDDLE; for (curr_align = GTK_OSD_LEFT; curr_align <= GTK_OSD_RIGHT; curr_align++) { positions[curr_pos][curr_align] = gtk_radio_button_new (group); gtk_container_add (GTK_CONTAINER (positions[curr_pos][curr_align]),position_icons[(curr_pos * 3) + curr_align]); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON(positions[curr_pos][curr_align]), FALSE); group =gtk_radio_button_group (GTK_RADIO_BUTTON(positions[curr_pos][curr_align])); if (sven->osd->pos == curr_pos && sven->osd->align == curr_align) { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(positions[curr_pos][curr_align]),TRUE); } gtk_table_attach (GTK_TABLE (position_table),positions[curr_pos][curr_align],curr_align, curr_align + 1,1, 2, GTK_FILL, GTK_FILL, 0, 0); } curr_pos = GTK_OSD_BOTTOM; for (curr_align = GTK_OSD_LEFT; curr_align <= GTK_OSD_RIGHT; curr_align++) { positions[curr_pos][curr_align] = gtk_radio_button_new (group); gtk_container_add (GTK_CONTAINER (positions[curr_pos][curr_align]),position_icons[(curr_pos * 3) + curr_align]); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON(positions[curr_pos][curr_align]), FALSE); group =gtk_radio_button_group (GTK_RADIO_BUTTON(positions[curr_pos][curr_align])); if (sven->osd->pos == curr_pos && sven->osd->align == curr_align) { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(positions[curr_pos][curr_align]),TRUE); } gtk_table_attach (GTK_TABLE (position_table),positions[curr_pos][curr_align],curr_align, curr_align + 1,2, 3, GTK_FILL, GTK_FILL, 0, 0); } // Vertical Offset label = gtk_label_new (_("Vertical Offset:")); gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 4,5,GTK_FILL, GTK_FILL, 0, 0); hbox = gtk_hbox_new (FALSE, 6); gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 4, 5,GTK_FILL, GTK_FILL, 0, 0); offset_obj = gtk_adjustment_new (sven->osd->timeout, 0, 300, 1, 1, 1); offset_spin = gtk_spin_button_new (GTK_ADJUSTMENT (offset_obj), 1.0, 0); gtk_spin_button_set_value (GTK_SPIN_BUTTON (offset_spin), sven->osd->voffset); gtk_box_pack_start (GTK_BOX (hbox), offset_spin, FALSE, FALSE, 0); unit_label = gtk_label_new (_("pixels")); gtk_misc_set_alignment (GTK_MISC (unit_label), 0.0, 0.0); gtk_label_set_justify (GTK_LABEL (unit_label), GTK_JUSTIFY_LEFT); gtk_box_pack_start (GTK_BOX (hbox), unit_label, FALSE, FALSE, 0); // Horizontal Offset label = gtk_label_new (_("Horizontal Offset:")); gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 5,6,GTK_FILL, GTK_FILL, 0, 0); hbox = gtk_hbox_new (FALSE, 6); gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 5,6,GTK_FILL, GTK_FILL, 0, 0); h_offset_obj = gtk_adjustment_new (sven->osd->timeout, 0, 300, 1, 1, 1); h_offset_spin = gtk_spin_button_new (GTK_ADJUSTMENT (h_offset_obj), 1.0, 0); gtk_spin_button_set_value (GTK_SPIN_BUTTON (h_offset_spin), sven->osd->hoffset); gtk_box_pack_start (GTK_BOX (hbox), h_offset_spin, FALSE, FALSE, 0); unit_label = gtk_label_new (_("pixels")); gtk_misc_set_alignment (GTK_MISC (unit_label), 0.0, 0.0); gtk_label_set_justify (GTK_LABEL (unit_label), GTK_JUSTIFY_LEFT); gtk_box_pack_start (GTK_BOX (hbox), unit_label, FALSE, FALSE, 0); // Background color label = gtk_label_new (_("Background Color:")); gtk_misc_set_alignment (GTK_MISC (label), 1.0, 0.5); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 6,7,GTK_FILL, GTK_FILL, 0, 0); hbox = gtk_hbox_new (FALSE, 6); gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 6,7,GTK_FILL, GTK_FILL, 0, 0); bg_color_enable=gtk_check_button_new_with_mnemonic (_("Enable")); gtk_box_pack_start (GTK_BOX (hbox), bg_color_enable, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (bg_color_enable), sven->osd->bg_color_on); gtk_color_selection_palette_from_string (sven->osd->bg_color,&colors,&n_colors); bg_color = gtk_color_button_new_with_color (colors); gtk_box_pack_start (GTK_BOX (hbox), bg_color, FALSE, FALSE, 0); sep = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (vbox), sep, FALSE, FALSE, 10); hbox1 = gtk_hbox_new (TRUE, 10); gtk_widget_show (hbox1); enable_xosd = gtk_check_button_new_with_mnemonic (_("Enable XOSD")); gtk_widget_show (enable_xosd); gtk_box_pack_start (GTK_BOX (hbox1), enable_xosd, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (enable_xosd), sven->osd->osd_on); enable_frame = gtk_check_button_new_with_mnemonic (_("Enable Frame")); gtk_widget_show (enable_frame); gtk_box_pack_start (GTK_BOX (hbox1), enable_frame, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (enable_frame), sven->osd->debug_frame); enable_shadow = gtk_check_button_new_with_mnemonic (_("Enable Shadow")); gtk_widget_show (enable_shadow); gtk_box_pack_start (GTK_BOX (hbox1), enable_shadow, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (enable_shadow), sven->osd->drop_shadow); gtk_box_pack_start (GTK_BOX (vbox), hbox1, FALSE, FALSE, 0); sep = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (vbox), sep, FALSE, FALSE,5); button1 = gtk_button_new_with_mnemonic (_("Test OSD")); gtk_widget_show (button1); gtk_box_pack_start (GTK_BOX (vbox), button1, FALSE, FALSE, 5); g_signal_connect(button1, "clicked", G_CALLBACK(test_osd),sven); gtk_widget_show_all (vbox); }
void create_plugins_gui(Sven *sven,GtkWidget *vbox1) { GtkTreeViewColumn *column; GtkCellRenderer *cell; GtkWidget *scrolled_win; GtkWidget *hbbox; GtkWidget *hbox; GtkWidget *frame; GtkWidget *alignment; GtkWidget *label; DEBUG_MSG("Start create_plugins_gui\n"); gtk_box_pack_start (GTK_BOX (vbox1), create_header(_("Plugins")), FALSE, FALSE, 0); plugins_model = gtk_tree_store_new (3,G_TYPE_BOOLEAN,G_TYPE_STRING,G_TYPE_STRING); plugins_tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (plugins_model)); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (plugins_tree_view), TRUE); plugins_selection = G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (plugins_tree_view))); gtk_tree_selection_set_mode (GTK_TREE_SELECTION (plugins_selection), GTK_SELECTION_SINGLE); g_signal_connect (G_OBJECT (plugins_selection),"changed",G_CALLBACK (prefs_plugins_list_clicked),sven); g_signal_connect(G_OBJECT(plugins_tree_view), "button-press-event",G_CALLBACK(plugin_list_event_mouseclick), sven); scrolled_win = gtk_scrolled_window_new(NULL, NULL); gtk_container_add(GTK_CONTAINER(scrolled_win), plugins_tree_view); gtk_container_border_width(GTK_CONTAINER(scrolled_win), 5); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_box_pack_start(GTK_BOX(vbox1), scrolled_win, TRUE, TRUE, 0); frame = gtk_frame_new (NULL); gtk_widget_show (frame); gtk_box_pack_start(GTK_BOX(vbox1), frame, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (frame), 2); gtk_frame_set_label_align (GTK_FRAME (frame), 0.05, 0.5); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT); label = gtk_label_new (_("Description")); gtk_widget_show (label); gtk_frame_set_label_widget (GTK_FRAME (frame), label); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment); gtk_container_add (GTK_CONTAINER (frame), alignment); gtk_container_set_border_width (GTK_CONTAINER (alignment), 2); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 5, 5, 5, 5); infotext = gtk_label_new (_("Not information")); gtk_widget_show (infotext); gtk_container_add (GTK_CONTAINER (alignment), infotext); GTK_WIDGET_SET_FLAGS (infotext, GTK_CAN_FOCUS); gtk_label_set_line_wrap (GTK_LABEL (infotext), TRUE); gtk_label_set_selectable (GTK_LABEL (infotext), TRUE); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox1), hbox, FALSE, FALSE, 5); hbbox = gtk_hbutton_box_new(); gtk_button_box_set_layout(GTK_BUTTON_BOX(hbbox), GTK_BUTTONBOX_START); gtk_button_box_set_spacing(GTK_BUTTON_BOX(hbbox), 10); gtk_button_box_set_child_size(GTK_BUTTON_BOX(hbbox), 85, 17); gtk_box_pack_start(GTK_BOX(hbox), hbbox, TRUE, TRUE, 0); prefs_plugins_config_wid = gtk_button_new_with_label(_("Configure")); g_signal_connect(G_OBJECT(prefs_plugins_config_wid ), "clicked", G_CALLBACK(prefs_plugins_configure),sven); gtk_box_pack_start(GTK_BOX(hbbox), prefs_plugins_config_wid, TRUE, TRUE, 0); prefs_plugins_about_wid = gtk_button_new_with_label(_("About")); g_signal_connect(G_OBJECT(prefs_plugins_about_wid), "clicked", G_CALLBACK(prefs_plugins_about), sven); gtk_box_pack_start(GTK_BOX(hbbox), prefs_plugins_about_wid, TRUE, TRUE, 0); cell = gtk_cell_renderer_toggle_new (); column = gtk_tree_view_column_new_with_attributes (_("Status"), cell, "active",0, NULL); gtk_tree_view_column_set_clickable (column, TRUE); g_signal_connect (G_OBJECT (cell), "toggled",G_CALLBACK (plugin_fixed_toggled),sven); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (plugins_tree_view), column); cell = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("Name"), cell, "markup", 1, NULL); gtk_tree_view_column_set_sort_column_id (column, 0); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (plugins_tree_view), column); cell = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("Module"), cell, "markup",2, NULL); gtk_tree_view_column_set_sort_column_id (column, 1); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (plugins_tree_view), column); gtk_widget_show(plugins_tree_view); add_print_plugins(GTK_TREE_VIEW (plugins_tree_view),sven); }
/** * Main routine. The main logic of ProbABEL can be found here * * \param argc Number of command line arguments * \param argv Vector containing the command line arguments * * \return 0 if all went well. Other integer numbers if an error * occurred */ int main(int argc, char * argv[]) { cmdvars input_var; input_var.set_variables(argc, argv); input_var.printinfo(); cout << "Reading info data...\n" << flush; mlinfo mli(input_var.getMlinfofilename(), input_var.getMapfilename()); int nsnps = mli.nsnps; phedata phd; cout << "Reading phenotype data...\n" << flush; int interaction_cox = create_phenotype(phd, input_var); masked_matrix invvarmatrix; if (input_var.getInverseFilename() != NULL) { loadInvSigma(input_var, phd, invvarmatrix); } gendata gtd; cout << "Reading genotype data... " << flush; if (!input_var.getIsFvf()) { // TODO(maartenk): remove timing code // make clock to time loading of the non filevector file std::clock_t start; start = std::clock(); // use the non-filevector input format gtd.re_gendata(input_var.getGenfilename(), nsnps, input_var.getNgpreds(), phd.nids_all, phd.nids, phd.allmeasured, input_var.getSkipd(), phd.idnames); // TODO(maartenk): remove timing code double millisec=((std::clock() - start) / (double)(CLOCKS_PER_SEC / 1000))/1000; cout << "done in "<< millisec<< " seconds.\n" << flush; } else { // use the filevector input format (missing second last skipd // parameter) gtd.re_gendata(input_var.getStrGenfilename(), nsnps, input_var.getNgpreds(), phd.nids_all, phd.nids, phd.allmeasured, phd.idnames); cout << "done.\n" << flush; } // estimate null model #if COXPH coxph_data nrgd = coxph_data(phd, gtd, -1); #else regdata nrgd = regdata(phd, gtd, -1, input_var.isIsInteractionExcluded()); #endif std::cout << " loaded null data..." << std::flush; #if LOGISTIC logistic_reg nrd = logistic_reg(nrgd); nrd.estimate(0, 0, input_var.getInteraction(), input_var.getNgpreds(), invvarmatrix, input_var.getRobust(), 1); #elif LINEAR linear_reg nrd = linear_reg(nrgd); #if DEBUG std::cout << "[DEBUG] linear_reg nrd = linear_reg(nrgd); DONE."; #endif nrd.estimate(0, 0, input_var.getInteraction(), input_var.getNgpreds(), invvarmatrix, input_var.getRobust(), 1); #elif COXPH coxph_reg nrd = coxph_reg(nrgd); nrd.estimate(nrgd, 0, input_var.getInteraction(), input_var.getNgpreds(), true, 1, mli, 0); #endif double null_loglik = nrd.loglik; std::cout << " estimated null model..."; // end null #if COXPH coxph_data rgd(phd, gtd, 0); #else regdata rgd(phd, gtd, 0, input_var.isIsInteractionExcluded()); #endif std::cout << " formed regression object...\n"; // Open a vector of files that will be used for output. Depending // on the number of genomic predictors we either open 5 files (one // for each model if we have prob data) or one (if we have dosage // data). std::string outfilename_str(input_var.getOutfilename()); std::vector<std::ofstream*> outfile; // Prob data: All models output. One file per model if (input_var.getNgpreds() == 2) { open_files_for_output(outfile, outfilename_str); if (input_var.getNohead() != 1) { create_header(outfile, input_var, phd, interaction_cox); } } else // Dosage data: Only additive model => only one output file { outfile.push_back( new std::ofstream((outfilename_str + "_add.out.txt").c_str())); if (!outfile[0]->is_open()) { std::cerr << "Cannot open file for writing: " << outfilename_str << "\n"; exit(1); } if (input_var.getNohead() != 1) { create_header(outfile, input_var, phd, interaction_cox); } } // END else: we have dosage data => only one file int maxmod = 5; // Total number of models (in random // order: additive, recessive, // dominant, over_dominant, 2df). Only // with dosage data can we run all of // them. For dosage data we can only // run the additive model. int start_pos, end_pos; std::vector<std::ostringstream *> beta_sebeta; // Han Chen std::vector<std::ostringstream *> covvalue; // Oct 26, 2009 std::vector<std::ostringstream *> chi2; // Create string streams for betas, SEs, etc. These are used to // later store the various output values that will be written to // files. for (int i = 0; i < maxmod; i++) { beta_sebeta.push_back(new std::ostringstream()); beta_sebeta[i]->precision(6); // *beta_sebeta[i] << scientific; // Han Chen covvalue.push_back(new std::ostringstream()); covvalue[i]->precision(6); // *covvalue[i] << scientific; // Oct 26, 2009 chi2.push_back(new std::ostringstream()); chi2[i]->precision(6); // *chi2[i] << scientific; } // Here we start the analysis for each SNP. for (int csnp = 0; csnp < nsnps; csnp++) { rgd.update_snp(>d, csnp); int poly = 1; if (fabs(rgd.freq) < 1.e-16 || fabs(1. - rgd.freq) < 1.e-16) { poly = 0; } if (fabs(mli.Rsq[csnp]) < 1.e-16) { poly = 0; } // Write mlinfo information to the output file(s) // Prob data: All models output. One file per model if (input_var.getNgpreds() == 2) { for (unsigned int file = 0; file < outfile.size(); file++) { write_mlinfo(outfile, file, mli, csnp, input_var, rgd.gcount, rgd.freq); } } else{ // Dosage data: only additive model int file = 0; write_mlinfo(outfile, file, mli, csnp, input_var, rgd.gcount, rgd.freq); maxmod = 1; // We can only calculate the additive // model with dosage data } // Run regression for each model for the current SNP for (int model = 0; model < maxmod; model++) { if (poly) // Allele freq is not too rare { #if LOGISTIC logistic_reg rd(rgd); #elif LINEAR linear_reg rd(rgd); #elif COXPH coxph_reg rd(rgd); #endif #if !COXPH if (input_var.getScore()) { rd.score(nrd.residuals, model, input_var.getInteraction(), input_var.getNgpreds(), invvarmatrix); } else { rd.estimate(0, model, input_var.getInteraction(), input_var.getNgpreds(), invvarmatrix, input_var.getRobust()); } #else rd.estimate(rgd, model, input_var.getInteraction(), input_var.getNgpreds(), true, 0, mli, csnp); #endif int number_of_rows_or_columns = rd.beta.nrow; start_pos = get_start_position(input_var, model, number_of_rows_or_columns); // The regression coefficients for the SNPs are in the // last rows of beta[] and sebeta[]. for (int pos = start_pos; pos < rd.beta.nrow; pos++) { *beta_sebeta[model] << input_var.getSep() << rd.beta[pos] << input_var.getSep() << rd.sebeta[pos]; // Han Chen #if !COXPH if (input_var.getInverseFilename() == NULL && !input_var.getAllcov() && input_var.getInteraction() != 0) { if (pos > start_pos) { if (model == 0) { if (input_var.getNgpreds() == 2) { if (pos > start_pos + 2) { *covvalue[model] << rd.covariance[pos - 3] << input_var.getSep() << rd.covariance[pos - 2]; } } // END ngpreds=2 else { *covvalue[model] << rd.covariance[pos - 1]; } } // END model == 0 else { *covvalue[model] << rd.covariance[pos - 1]; } // END model != 0 } // END if pos > start_pos } #endif // Oct 26, 2009 } // END for(pos = start_pos; pos < rd.beta.nrow; pos++) // calculate chi^2 // ________________________________ // cout << rd.loglik<<" "<<input_var.getNgpreds() << "\n"; if (input_var.getInverseFilename() == NULL) { // Only if we don't have an inv.sigma file can we use LRT if (input_var.getScore() == 0) { double loglik = rd.loglik; if (rgd.gcount != gtd.nids) { // If SNP data is missing we didn't // correctly compute the null likelihood // Recalculate null likelihood by // stripping the SNP data column(s) from // the X matrix in the regression object // and run the null model estimation again // for this SNP. #if !COXPH regdata new_rgd = rgd; #else coxph_data new_rgd = rgd; #endif new_rgd.remove_snp_from_X(); #ifdef LINEAR linear_reg new_null_rd(new_rgd); #elif LOGISTIC logistic_reg new_null_rd(new_rgd); #endif #if !COXPH new_null_rd.estimate(0, model, input_var.getInteraction(), input_var.getNgpreds(), invvarmatrix, input_var.getRobust(), 1); #else coxph_reg new_null_rd(new_rgd); new_null_rd.estimate(new_rgd, model, input_var.getInteraction(), input_var.getNgpreds(), true, 1, mli, csnp); #endif *chi2[model] << 2. * (loglik - new_null_rd.loglik); } else { // No missing SNP data, we can compute the LRT *chi2[model] << 2. * (loglik - null_loglik); } } else{ // We want score test output *chi2[model] << rd.chi2_score; } } // END if( inv.sigma == NULL ) else if (input_var.getInverseFilename() != NULL) { // We can't use the LRT here, because mmscore is a // REML method. Therefore go for the Wald test if (input_var.getNgpreds() == 2 && model == 0) { /* For the 2df model we can't simply use the * Wald statistic. This can be fixed using the * equation just below Eq.(4) in the ProbABEL * paper. TODO LCK */ *chi2[model] << "NaN"; } else { double Z = rd.beta[start_pos] / rd.sebeta[start_pos]; *chi2[model] << Z * Z; } } } // END first part of if(poly); allele not too rare else { // SNP is rare: beta, sebeta, chi2 = NaN int number_of_rows_or_columns = rgd.X.ncol; start_pos = get_start_position(input_var, model, number_of_rows_or_columns); if (input_var.getInteraction() != 0 && !input_var.getAllcov() && input_var.getNgpreds() != 2) { start_pos++; } if (input_var.getNgpreds() == 0) { end_pos = rgd.X.ncol; } else{ end_pos = rgd.X.ncol - 1; } if (input_var.getInteraction() != 0) { end_pos++; } for (int pos = start_pos; pos <= end_pos; pos++) { *beta_sebeta[model] << input_var.getSep() << "NaN" << input_var.getSep() << "NaN"; } if (input_var.getNgpreds() == 2) { // Han Chen #if !COXPH if (!input_var.getAllcov() && input_var.getInteraction() != 0) { if (model == 0) { *covvalue[model] << "NaN" << input_var.getSep() << "NaN"; } else{ *covvalue[model] << "NaN"; } } #endif // Oct 26, 2009 *chi2[model] << "NaN"; } else{ // ngpreds==1 (and SNP is rare) if (input_var.getInverseFilename() == NULL) { // Han Chen #if !COXPH if (!input_var.getAllcov() && input_var.getInteraction() != 0) { *covvalue[model] << "NaN"; } #endif // Oct 26, 2009 } // END if getInverseFilename == NULL *chi2[model] << "NaN"; } // END ngpreds == 1 (and SNP is rare) } // END else: SNP is rare } // END of model cycle // Start writing beta's, se_beta's etc. to file if (input_var.getNgpreds() == 2) { for (int model = 0; model < maxmod; model++) { *outfile[model] << beta_sebeta[model]->str() << input_var.getSep(); #if !COXPH if (!input_var.getAllcov() && input_var.getInteraction() != 0) { *outfile[model] << covvalue[model]->str() << input_var.getSep(); } #endif *outfile[model] << chi2[model]->str() << "\n"; } // END for loop over all models } else // Dose data: only additive model. Only one output file { *outfile[0] << beta_sebeta[0]->str() << input_var.getSep(); #if !COXPH if (!input_var.getAllcov() && input_var.getInteraction() != 0) { *outfile[0] << covvalue[0]->str() << input_var.getSep(); } #endif *outfile[0] << chi2[0]->str() << "\n"; } // End ngpreds == 1 when writing output files // Clean chi2 and other streams for (int model = 0; model < maxmod; model++) { beta_sebeta[model]->str(""); // Han Chen covvalue[model]->str(""); // Oct 26, 2009 chi2[model]->str(""); } update_progress_to_cmd_line(csnp, nsnps); } // END for loop over all SNPs // We're almost done. All computations have finished, time to // clean up. std::cout << setprecision(2) << fixed; std::cout << "\b\b\b\b\b\b\b\b\b" << 100.; std::cout << "%... done\n"; // Close output files for (unsigned int i = 0; i < outfile.size(); i++) { outfile[i]->close(); delete outfile[i]; } // delete gtd; // Clean up a couple of vectors std::vector<std::ostringstream *>::iterator it = beta_sebeta.begin(); while (it != beta_sebeta.end()) { delete *it; ++it; } it = covvalue.begin(); while (it != covvalue.end()) { delete *it; ++it; } it = chi2.begin(); while (it != chi2.end()) { delete *it; ++it; } return (0); }
LRESULT playlist_view::on_message(HWND wnd, UINT msg, WPARAM wp, LPARAM lp) { switch (msg) { case WM_NCCREATE: wnd_playlist = wnd; initialised = true; list_playlist.add_item(this); g_playlist_message_window.add_ref(); break; case WM_CREATE: { pfc::com_ptr_t<IDropTarget_playlist> IDT_playlist = new IDropTarget_playlist(this); RegisterDragDrop(wnd, IDT_playlist.get_ptr()); if (true) { m_theme = IsThemeActive() && IsAppThemed() ? OpenThemeData(wnd, L"ListView") : NULL; SetWindowTheme(wnd, L"Explorer", NULL); } m_always_show_focus = config_object::g_get_data_bool_simple(standard_config_objects::bool_playback_follows_cursor, false); on_playlist_font_change(); create_header(true); drawing_enabled = true; m_cache.initialise(); } return 0; case WM_DESTROY: m_edit_save = false; exit_inline_edit(); m_cache.deinitialise(); RevokeDragDrop(wnd); SendMessage(wnd, WM_SETFONT, 0, 0); SendMessage(wnd_header, WM_SETFONT, 0, 0); { if (m_theme) CloseThemeData(m_theme); m_theme = NULL; } m_selection_holder.release(); break; case WM_NCDESTROY: g_playlist_message_window.release(); wnd_playlist = 0; initialised = false; list_playlist.remove_item(this); m_shown = false; // if (!list_playlist.get_count()) // { // g_playlist_entries.rebuild_all(); // } break; case WM_THEMECHANGED: { if (m_theme) CloseThemeData(m_theme); m_theme = IsThemeActive() && IsAppThemed() ? OpenThemeData(wnd, L"ListView") : 0; } break; case WM_SHOWWINDOW: if (wp == TRUE && lp == 0 && !m_shown) { static_api_ptr_t<playlist_manager> playlist_api; ensure_visible(playlist_api->activeplaylist_get_focus_item()); m_shown = true; } break; case WM_WINDOWPOSCHANGED: { LPWINDOWPOS lpwp = (LPWINDOWPOS)lp; if (!(lpwp->flags & SWP_NOSIZE)) { on_size(lpwp->cx, lpwp->cy); } } break; case WM_ERASEBKGND: return TRUE; break; case WM_PAINT: { PAINTSTRUCT ps; HDC dc_paint = BeginPaint(wnd, &ps); RECT rc_update, rc_playlist; get_playlist_rect(&rc_playlist); rc_update = ps.rcPaint; if (rc_update.top<rc_playlist.top) rc_update.top = rc_playlist.top; if (rc_update.bottom >= rc_update.top) { int item_height = get_item_height(); int start_item = (rc_update.top - rc_playlist.top) / item_height; int end_item = (rc_update.bottom - rc_playlist.top) / item_height; if (((end_item - start_item) + 1)*item_height < rc_update.bottom - rc_update.top) end_item++; { draw_items(dc_paint, start_item, 1 + (end_item - start_item)); } } EndPaint(wnd, &ps); } return 0; case WM_SETREDRAW: drawing_enabled = (wp != 0); return 0; case WM_MOUSEACTIVATE: if (GetFocus() != wnd) m_no_next_edit = true; return MA_ACTIVATE; case WM_UPDATEUISTATE: RedrawWindow(wnd_playlist, 0, 0, RDW_INVALIDATE); break; case WM_KILLFOCUS: RedrawWindow(wnd_playlist, 0, 0, RDW_INVALIDATE | RDW_UPDATENOW); m_selection_holder.release(); break; case WM_SETFOCUS: //if (msg == WM_SETFOCUS && (HWND)wp != wnd) //m_no_next_edit = true; RedrawWindow(wnd_playlist, 0, 0, RDW_INVALIDATE | RDW_UPDATENOW); m_selection_holder = static_api_ptr_t<ui_selection_manager>()->acquire(); m_selection_holder->set_playlist_selection_tracking(); break; case WM_GETDLGCODE: return DLGC_WANTALLKEYS; case WM_KEYDOWN: { static_api_ptr_t<playlist_manager> playlist_api; uie::window_ptr p_this = this; //DWORD vk_slash = VkKeyScan('/'); if (wp == VK_CONTROL) g_drag_lmb = true; if (m_prevent_wm_char_processing = process_keydown(msg, lp, wp, true)) return 0; else { SendMessage(wnd, WM_CHANGEUISTATE, MAKEWPARAM(UIS_CLEAR, UISF_HIDEFOCUS), NULL); if (wp == VK_HOME || wp == VK_DOWN || wp == VK_END || wp == VK_PRIOR || wp == VK_NEXT || wp == VK_UP) { int focus = playlist_api->activeplaylist_get_focus_item(); int total = playlist_api->activeplaylist_get_item_count(); if ((wp == VK_HOME || wp == VK_PRIOR || wp == VK_UP)) { // if (focus == 0) return 0; } if ((wp == VK_END || wp == VK_NEXT || wp == VK_DOWN)) { // if (focus == total - 1) return 0; } SCROLLINFO si; memset(&si, 0, sizeof(si)); si.cbSize = sizeof(si); si.fMask = SIF_PAGE | SIF_POS; GetScrollInfo(wnd_playlist, SB_VERT, &si); int offset = 0; int scroll = scroll_item_offset; if (wp == VK_HOME) scroll = 0; else if (wp == VK_PRIOR && focus == scroll_item_offset) scroll -= si.nPage; else if (wp == VK_UP) { if (focus <= scroll_item_offset) scroll = focus - 1; else if (focus > si.nPos + si.nPage - 1) scroll = focus - 1 - si.nPage + 1; } else if (wp == VK_DOWN) { if (focus < scroll_item_offset) scroll = focus + 1; else if (focus >= si.nPos + si.nPage - 1) scroll = focus + 1 - si.nPage + 1; } else if (wp == VK_END) scroll = total - 1; else if (wp == VK_NEXT && focus == si.nPos + si.nPage - 1) scroll += si.nPage; drawing_enabled = false; si.nPos = scroll; si.fMask = SIF_POS; scroll_item_offset = SetScrollInfo(wnd_playlist, SB_VERT, &si, true); if (wp == VK_HOME) offset = 0 - focus; else if (wp == VK_PRIOR) offset = scroll_item_offset - focus; else if (wp == VK_END) offset = total - focus - 1; else if (wp == VK_NEXT) offset = get_last_viewable_item() - focus; else if (wp == VK_DOWN) offset = 1; else if (wp == VK_UP) offset = -1; //if (offset) process_keydown(offset, ((HIWORD(lp) & KF_ALTDOWN) != 0), drawing_enabled, (HIWORD(lp) & KF_REPEAT) != 0); drawing_enabled = true; RedrawWindow(wnd_playlist, 0, 0, RDW_INVALIDATE | RDW_UPDATENOW); return 0; } else if (wp == VK_SPACE) { int focus = playlist_api->activeplaylist_get_focus_item(); set_sel_single(focus, true, false, false); return 0; } else if (wp == VK_RETURN) { bool ctrl_down = 0 != (GetKeyState(VK_CONTROL) & KF_UP); int focus = playlist_api->activeplaylist_get_focus_item(); unsigned active = playlist_api->get_active_playlist(); if (ctrl_down) { if (active != -1 && focus != -1) playlist_api->queue_add_item_playlist(active, focus); } else { // playlist_api->set_playing_playlist(active); unsigned focus = playlist_api->activeplaylist_get_focus_item(); //unsigned active = playlist_api->get_active_playlist(); //playlist_api->playlist_set_playback_cursor(active, focus); playlist_api->activeplaylist_execute_default_action(focus); //static_api_ptr_t<play_control>()->play_start(play_control::track_command_settrack); } return 0; } else if (wp == VK_SHIFT) { if (!(HIWORD(lp) & KF_REPEAT)) g_shift_item_start = playlist_api->activeplaylist_get_focus_item(); } else if (wp == VK_F2) { unsigned count = g_get_cache().active_column_get_active_count(); if (count) { unsigned focus = playlist_api->activeplaylist_get_focus_item(); if (focus != pfc_infinite) { t_size i, pcount = playlist_api->activeplaylist_get_item_count(); bit_array_bittable sel(pcount); playlist_api->activeplaylist_get_selection_mask(sel); pfc::list_t<t_size> indices; indices.prealloc(32); for (i = 0; i<pcount; i++) if (sel[i]) indices.add_item(i); /*t_size start = focus, end = focus; if (sel[start] && pcount) { while (start>0 && sel[start-1]) start--; while (end<pcount-1 && sel[end+1]) end++; }*/ unsigned count = g_get_cache().active_column_get_active_count(); unsigned column; for (column = 0; column<count; column++) { if (!g_get_columns()[g_get_cache().active_column_active_to_actual(column)]->edit_field.is_empty()) { //create_inline_edit_v2(start, end-start+1, column); create_inline_edit_v2(indices, column); break; } } } } } else if (wp == VK_DELETE) { playlist_api->activeplaylist_undo_backup(); playlist_api->activeplaylist_remove_selection(); } else if (wp == VK_F3) { standard_commands::main_playlist_search(); } /*else if (vk_slash != -1 && wp == LOWORD(vk_slash)) { HWND wnd_search = m_searcher.create(wnd); on_size(); ShowWindow(wnd_search, SW_SHOWNORMAL); ; }*/ } } break; case WM_CHAR: if (!m_prevent_wm_char_processing) { //if (!(HIWORD(lp) & KF_REPEAT)) { if ((GetKeyState(VK_CONTROL) & KF_UP)) { static_api_ptr_t<playlist_manager> playlist_api; if (wp == 1) //Ctrl-A { playlist_api->activeplaylist_set_selection(bit_array_true(), bit_array_true()); return 0; } else if (wp == 26) //Ctrl-Z { playlist_api->activeplaylist_undo_restore(); return 0; } else if (wp == 25) //Ctrl-Y { playlist_api->activeplaylist_redo_restore(); return 0; } else if (wp == 24) //Ctrl-X { playlist_utils::cut(); return 0; } else if (wp == 3) //Ctrl-C { playlist_utils::copy(); return 0; } else if (wp == 6) //Ctrl-F { standard_commands::main_playlist_search(); return 0; } else if (wp == 22) //Ctrl-V { playlist_utils::paste(wnd); return 0; } } } } break; case WM_KEYUP: if (process_keydown(msg, lp, wp, true)) return 0; break; case WM_SYSKEYUP: if (process_keydown(msg, lp, wp, true)) return 0; break; case WM_SYSKEYDOWN: { uie::window_ptr p_this = this; if (m_prevent_wm_char_processing = process_keydown(msg, lp, wp, true)) return 0; } break; case WM_LBUTTONDOWN: { if (0 && g_tooltip) { MSG message; memset(&message, 0, sizeof(MSG)); message.hwnd = wnd; message.message = msg; message.wParam = wp; message.lParam = lp; uSendMessage(g_tooltip, TTM_RELAYEVENT, 0, (LPARAM)&message); } bool b_was_focused = GetFocus() == wnd; if (!b_was_focused) m_no_next_edit = true; //#ifdef INLINE_EDIT exit_inline_edit(); // g_no_next_edit = false; //#endif dragged = false; SetFocus(wnd); SetCapture(wnd); static_api_ptr_t<playlist_manager> playlist_api; g_drag_lmb = true; int focus = playlist_api->activeplaylist_get_focus_item(); drag_start_lmb.x = GET_X_LPARAM(lp); drag_start_lmb.y = GET_Y_LPARAM(lp); int item_height = get_item_height(); int idx = hittest_item(GET_X_LPARAM(lp), GET_Y_LPARAM(lp)); // int idx = ((GET_Y_LPARAM(lp) -get_header_height()) / item_height) + scroll_item_offset; // if( idx >= 0 && idx <playlist_api->activeplaylist_get_item_count() && GET_X_LPARAM(lp) < g_playlist_entries.get_total_width_actual()) if (idx >= 0) { // playlist_oper * playlist_api = playlist_api; // playlist_api->set_playback_cursor(idx); //#ifdef INLINE_EDIT m_prev_sel = (playlist_api->activeplaylist_is_item_selected(idx) && !m_wnd_edit && (playlist_api->activeplaylist_get_selection_count(2) == 1)); //#endif if (!is_visible(idx)) SendMessage(wnd_playlist, WM_VSCROLL, MAKEWPARAM(SB_LINEDOWN, 0), 0); if (wp & MK_CONTROL && wp & MK_SHIFT) { playlist_api->activeplaylist_move_selection(idx - focus); dragged = true; drag_type = 0; } else if (wp & MK_SHIFT) { drag_type = 2; dragitem = idx, dragstartitem = idx; int n = (cfg_alternative_sel ? focus : g_shift_item_start), t = idx; bool focus_sel = playlist_api->activeplaylist_is_item_selected(focus); set_sel_range(n, t, (cfg_alternative_sel != 0), (cfg_alternative_sel ? !focus_sel : false)); playlist_api->activeplaylist_set_focus_item(idx); dragged = true; } else if (wp & MK_CONTROL) { /* drag_type = 2; dragitem = idx,dragstartitem=idx; set_sel_single(idx, false, true, false); dragged = true;*/ } else if (playlist_api->activeplaylist_is_item_selected(idx)) { drag_type = 1; dragitem = idx, dragstartitem = idx; playlist_api->activeplaylist_undo_backup(); playlist_api->activeplaylist_set_focus_item(idx); dragged = false; } else { drag_type = 2; dragitem = idx, dragstartitem = idx;//item irrelevant actually; set_sel_single(idx, false, true, true); /* bit_array_bittable mask(playlist_api->activeplaylist_get_item_count()); // playlist_api->activeplaylist_is_item_selected_mask(mask); int n, t = playlist_api->activeplaylist_get_item_count(); for (n = 0;n <t;n++) { if (n==idx) mask.set(n, true); else mask.set(n, false); } console::info("crap"); playlist_api->set_sel_mask(mask); playlist_api->activeplaylist_set_focus_item(idx);*/ dragged = false; } } else { // console::info("wow"); // bit_array_bittable mask(playlist_api->activeplaylist_get_item_count()); playlist_api->activeplaylist_set_selection(bit_array_true(), bit_array_false()); dragged = true; drag_type = 0; } } break; case WM_RBUTTONUP: m_no_next_edit = false; break; case WM_MBUTTONUP: { m_no_next_edit = false; unsigned idx = hittest_item(GET_X_LPARAM(lp), GET_Y_LPARAM(lp)); playlist_mclick_actions::run(cfg_playlist_middle_action, idx != -1, idx); } break; case WM_LBUTTONUP: { if (0 && g_tooltip) { MSG message; memset(&message, 0, sizeof(MSG)); message.hwnd = wnd; message.message = msg; message.wParam = wp; message.lParam = lp; uSendMessage(g_tooltip, TTM_RELAYEVENT, 0, (LPARAM)&message); } ReleaseCapture(); g_drag_lmb = false; int idx = hittest_item(GET_X_LPARAM(lp), GET_Y_LPARAM(lp), true); //((GET_Y_LPARAM(lp) -get_header_height()) / get_item_height()) + scroll_item_offset; static_api_ptr_t<playlist_manager> playlist_api; if (!dragged) { if (wp & MK_CONTROL) { // int idx_down = hittest_item(drag_start_lmb.x, drag_start_lmb.y); if (idx >= 0) set_sel_single(idx, true, true, false); } else { // int item_height = get_item_height(); // int idx = ((GET_Y_LPARAM(lp) - get_header_height()) / item_height) + scroll_item_offset; if (idx >= 0 /*&& idx < playlist_api->activeplaylist_get_item_count() && (GET_X_LPARAM(lp) < g_playlist_entries.get_total_width_actual())*/) { if (!m_no_next_edit && cfg_inline_edit && playlist_api->activeplaylist_is_item_selected(idx) && m_prev_sel /*&& !dragged*/) { //if (m_no_next_edit && GetCapture() == wnd) ReleaseCapture(); { exit_inline_edit(); if (main_window::config_get_inline_metafield_edit_mode() != main_window::mode_disabled) { m_edit_index = idx; long width; m_edit_column = hittest_column(GET_X_LPARAM(lp), width); if (m_edit_column >= 0 && !g_get_columns()[g_get_cache().active_column_active_to_actual(m_edit_column)]->edit_field.is_empty()) { m_edit_timer = (SetTimer(wnd, EDIT_TIMER_ID, GetDoubleClickTime(), 0) != 0); } } } } int focus = playlist_api->activeplaylist_get_focus_item(); set_sel_single(focus, false, false, true); } } } dragged = true; drag_type = 0; dragstartitem = 0; dragitem = 0; //#ifdef INLINE_EDIT m_no_next_edit = false; //#endif } break; case WM_MOUSEMOVE: { if (0 && g_tooltip) { MSG message; memset(&message, 0, sizeof(MSG)); message.hwnd = wnd; message.message = msg; message.wParam = wp; message.lParam = lp; uSendMessage(g_tooltip, TTM_RELAYEVENT, 0, (LPARAM)&message); } const unsigned cx_drag = (unsigned)abs(GetSystemMetrics(SM_CXDRAG)); const unsigned cy_drag = (unsigned)abs(GetSystemMetrics(SM_CYDRAG)); if (!g_dragging && ((g_dragging1 && wp & MK_RBUTTON && (abs(drag_start.x - GET_X_LPARAM(lp)) > cx_drag || abs(drag_start.y - GET_Y_LPARAM(lp)) > cy_drag)) || (g_drag_lmb && (wp & MK_LBUTTON) && (wp & MK_CONTROL) && (abs(drag_start_lmb.x - GET_X_LPARAM(lp)) > 3 || abs(drag_start_lmb.y - GET_Y_LPARAM(lp)) > 3)))) { static_api_ptr_t<playlist_manager> playlist_api; metadb_handle_list data; playlist_api->activeplaylist_get_selected_items(data); if (data.get_count() > 0) { static_api_ptr_t<playlist_incoming_item_filter> incoming_api; IDataObject * pDataObject = incoming_api->create_dataobject(data); if (pDataObject) { //RegisterClipboardFormat(_T("foo_ui_columns"); if (g_tooltip) { DestroyWindow(g_tooltip); g_tooltip = 0; last_idx = -1; last_column = -1; } DWORD blah; { pfc::com_ptr_t<IDropSource_playlist> p_IDropSource_playlist = new IDropSource_playlist(this); DoDragDrop(pDataObject, p_IDropSource_playlist.get_ptr(), DROPEFFECT_COPY, &blah); } pDataObject->Release(); } } data.remove_all(); g_dragging = false; g_dragging1 = false; g_drag_lmb = false; if (wp & MK_LBUTTON) { dragged = true; drag_type = 0; dragstartitem = 0; dragitem = 0; } } if (cfg_tooltip && (GET_Y_LPARAM(lp) > get_header_height())) { int item_height = get_item_height(); int idx = hittest_item(GET_X_LPARAM(lp), GET_Y_LPARAM(lp)); long cx; int column = hittest_column(GET_X_LPARAM(lp), cx); // unsigned act_col = g_cache.active_column_active_to_actual(column); if (column >= 0 && idx >= 0) { if (last_idx != (idx) || last_column != column) { if (!cfg_tooltips_clipped || is_item_clipped(idx, column)) { pfc::string8 src; g_cache.active_get_display_name(idx, column, src); pfc::string8 temp; titleformat_compiler::remove_color_marks(src, temp); temp.replace_char(9, 0x20); CreateToolTip(temp); } else { DestroyWindow(g_tooltip); g_tooltip = 0; last_idx = -1; last_column = -1; } POINT a; a.x = cx + 3; a.y = (idx - scroll_item_offset) * item_height + get_header_height(); ClientToScreen(wnd_playlist, &a); tooltip.top = a.y; tooltip.bottom = a.y + item_height; tooltip.left = a.x; tooltip.right = a.x + get_column_width(column); } last_idx = idx; last_column = column; } else { DestroyWindow(g_tooltip); g_tooltip = 0; last_idx = -1; last_column = -1; } } if (drag_type && (wp & MK_LBUTTON) && !(GetKeyState(VK_SHIFT) & KF_UP) && !(GetKeyState(VK_CONTROL) & KF_UP)) { RECT rc; get_playlist_rect(&rc); static_api_ptr_t<playlist_manager> playlist_api; int total = playlist_api->activeplaylist_get_item_count(); int item_height = get_item_height(); int valid_idx = hittest_item(GET_X_LPARAM(lp), GET_Y_LPARAM(lp), false); int idx = hittest_item_no_scroll(GET_X_LPARAM(lp), GET_Y_LPARAM(lp), false); // (GET_Y_LPARAM(lp) - get_header_height()) / (item_height); int items_count = ((rc.bottom - rc.top) / item_height) + 1; if ((idx + scroll_item_offset) != dragitem || GET_Y_LPARAM(lp) < get_header_height()) //(idx + scroll_item_offset) < playlist_api->activeplaylist_get_item_count() { if (idx >= items_count - 1) { bool need_redrawing = false; int focus = playlist_api->activeplaylist_get_focus_item(); SCROLLINFO si; memset(&si, 0, sizeof(si)); si.cbSize = sizeof(si); si.fMask = SIF_POS; GetScrollInfo(wnd_playlist, SB_VERT, &si); int old_offset = si.nPos; si.nPos += 3; scroll_item_offset = SetScrollInfo(wnd_playlist, SB_VERT, &si, true); if (old_offset != scroll_item_offset) need_redrawing = true; int t = scroll_item_offset + items_count - 2; //n=dragitem, if (t > total) t = total - 1; if (t != dragitem) { drawing_enabled = false; if (drag_type == 1) playlist_api->activeplaylist_move_selection((rc.bottom - rc.top) / item_height + scroll_item_offset - focus - 1); else if (drag_type == 2) { set_sel_range(dragstartitem, t, false); playlist_api->activeplaylist_set_focus_item(t); } dragitem = t; drawing_enabled = true; need_redrawing = true; } if (need_redrawing) RedrawWindow(wnd_playlist, 0, 0, RDW_INVALIDATE | RDW_UPDATENOW); } else if (idx < 0 || GET_Y_LPARAM(lp) < get_header_height() || GET_Y_LPARAM(lp) < 0) { int focus = playlist_api->activeplaylist_get_focus_item(); bool need_redrawing = false; SCROLLINFO si; memset(&si, 0, sizeof(si)); si.cbSize = sizeof(si); si.fMask = SIF_POS; GetScrollInfo(wnd_playlist, SB_VERT, &si); int old_offset = si.nPos; si.nPos -= 3; scroll_item_offset = SetScrollInfo(wnd_playlist, SB_VERT, &si, true); if (old_offset != scroll_item_offset) need_redrawing = true; if (dragitem != scroll_item_offset) { drawing_enabled = false; if (drag_type == 1) playlist_api->activeplaylist_move_selection(scroll_item_offset - focus); else if (drag_type == 2) { set_sel_range(dragstartitem, scroll_item_offset, false); playlist_api->activeplaylist_set_focus_item(scroll_item_offset); RedrawWindow(wnd_playlist, 0, 0, RDW_INVALIDATE | RDW_UPDATENOW); } dragitem = scroll_item_offset; drawing_enabled = true; need_redrawing = true; } if (need_redrawing) RedrawWindow(wnd_playlist, 0, 0, RDW_INVALIDATE | RDW_UPDATENOW); } else { int focus = playlist_api->activeplaylist_get_focus_item(); if (drag_type == 1) playlist_api->activeplaylist_move_selection(idx + scroll_item_offset - focus); else if (drag_type == 2) { if (valid_idx >= 0) { drawing_enabled = false; set_sel_range(dragstartitem, valid_idx, false); playlist_api->activeplaylist_set_focus_item(valid_idx); drawing_enabled = true; RedrawWindow(wnd_playlist, 0, 0, RDW_INVALIDATE | RDW_UPDATENOW); } } dragitem = valid_idx; dragged = true; } } } else if (!(wp & MK_LBUTTON)) drag_type = 0; } break; case WM_LBUTTONDBLCLK: { int idx = hittest_item(GET_X_LPARAM(lp), GET_Y_LPARAM(lp), true); if (idx >= 0) { //#ifdef INLINE_EDIT exit_inline_edit(); m_no_next_edit = true; //#endif //if (!is_visible(idx)) uSendMessage(wnd_playlist, WM_VSCROLL, MAKEWPARAM(SB_LINEDOWN, 0),0); #if 0 // DEATH's code case WM_LBUTTONDBLCLK: { int idx = item_from_point((short)HIWORD(lp)); if (idx >= 0 && idx<(int)m_api->activeplaylist_get_item_count()) { m_api->activeplaylist_set_focus_item(idx); static_api_ptr_t<play_control>()->play_start(play_control::TRACK_COMMAND_SETTRACK); } } return 0; #endif static_api_ptr_t<playlist_manager> playlist_api; //unsigned active = playlist_api->get_active_playlist(); // playlist_api->set_playing_playlist(active); //playlist_api->playlist_set_playback_cursor(active, idx); //playlist_api->queue_flush(); unsigned focus = playlist_api->activeplaylist_get_focus_item(); playlist_api->activeplaylist_execute_default_action(focus); } else if (cfg_playlist_double.get_value().m_command != pfc::guid_null) { mainmenu_commands::g_execute(cfg_playlist_double.get_value().m_command); } dragged = true; } break; case WM_RBUTTONDOWN: { if (wnd_playlist) SetFocus(wnd_playlist); g_dragging1 = true; drag_start.x = GET_X_LPARAM(lp); drag_start.y = GET_Y_LPARAM(lp); static_api_ptr_t<playlist_manager> playlist_api; // int item_height = get_item_height(); // int idx = ((GET_Y_LPARAM(lp) - get_header_height()) / item_height) + scroll_item_offset; int idx = hittest_item(GET_X_LPARAM(lp), GET_Y_LPARAM(lp), true); if (idx != -1 && !is_visible(idx)) SendMessage(wnd_playlist, WM_VSCROLL, MAKEWPARAM(SB_LINEDOWN, 0), 0); if (idx >= 0 /*&& idx < playlist_api->activeplaylist_get_item_count() && (GET_X_LPARAM(lp) < g_playlist_entries.get_total_width_actual())*/) { if (!playlist_api->activeplaylist_is_item_selected(idx) && !(GetKeyState(VK_CONTROL) & KF_UP)) { set_sel_single(idx, false, false, true); } playlist_api->activeplaylist_set_focus_item(idx); } } break; case WM_MOUSEWHEEL: {//GET_WHEEL_DELTA_WPARAM exit_inline_edit(); if (1 || (wp & MK_CONTROL)) { LONG_PTR style = GetWindowLongPtr(wnd_playlist, GWL_STYLE); if (!(style & WS_VSCROLL) || ((wp & MK_CONTROL) && (style & WS_HSCROLL))) { if ((style & WS_HSCROLL)) { SCROLLINFO si; memset(&si, 0, sizeof(SCROLLINFO)); si.fMask = SIF_PAGE; si.cbSize = sizeof(SCROLLINFO); GetScrollInfo(wnd, SB_HORZ, &si); int new_pos = horizontal_offset; int old_pos = horizontal_offset; unsigned scroll_lines = GetNumScrollLines(); int zDelta = short(HIWORD(wp)); if (scroll_lines == -1) { scroll_lines = si.nPage > 1 ? si.nPage - 1 : 1; } else scroll_lines *= 3; int delta = MulDiv(zDelta, scroll_lines, 120); if (!si.nPage) si.nPage++; if (delta < 0 && delta*-1 > si.nPage) { delta = si.nPage*-1; if (delta >1) delta--; } else if (delta > 0 && delta > si.nPage) { delta = si.nPage; if (delta >1) delta--; } scroll(scroll_horizontally, scroll_position_delta, -delta); } return 1; } } SCROLLINFO si; memset(&si, 0, sizeof(SCROLLINFO)); si.fMask = SIF_PAGE; si.cbSize = sizeof(SCROLLINFO); GetScrollInfo(wnd, SB_VERT, &si); int new_pos = scroll_item_offset; int old_pos = scroll_item_offset; unsigned scroll_lines = GetNumScrollLines(); int zDelta = short(HIWORD(wp)); if (scroll_lines == -1) { scroll_lines = si.nPage > 1 ? si.nPage - 1 : 1; } int delta = MulDiv(zDelta, scroll_lines, 120); if (!si.nPage) si.nPage++; if (delta < 0 && delta*-1 > si.nPage) { delta = si.nPage*-1; if (delta >1) delta--; } else if (delta > 0 && delta > si.nPage) { delta = si.nPage; if (delta >1) delta--; } scroll(scroll_vertically, scroll_position_delta, -delta); } return 1; case WM_VSCROLL: { exit_inline_edit(); scroll(scroll_vertically, scroll_sb, LOWORD(wp)); } return 0; case WM_HSCROLL: { exit_inline_edit(); scroll(scroll_horizontally, scroll_sb, LOWORD(wp)); } return 0; case WM_MENUSELECT: { if (HIWORD(wp) & MF_POPUP) { m_status_override.release(); } else { if (g_main_menu_a.is_valid() || g_main_menu_b.is_valid()) { unsigned id = LOWORD(wp); bool set = false; pfc::string8 desc; if (g_main_menu_a.is_valid() && id < MENU_B_BASE) { set = g_main_menu_a->get_description(id - MENU_A_BASE, desc); } else if (g_main_menu_b.is_valid()) { contextmenu_node * node = g_main_menu_b->find_by_id(id - MENU_B_BASE); if (node) set = node->get_description(desc); } service_ptr_t<ui_status_text_override> p_status_override; if (set) { get_host()->override_status_text_create(p_status_override); if (p_status_override.is_valid()) { p_status_override->override_text(desc); } } m_status_override = p_status_override; } } } break; case WM_CONTEXTMENU: { uie::window_ptr p_this_temp = this; if ((HWND)wp == wnd_header) { POINT pt = { (short)LOWORD(lp), (short)HIWORD(lp) }; POINT temp; temp.x = pt.x; temp.y = pt.y; ScreenToClient(wnd_header, &temp); HDHITTESTINFO hittest; hittest.pt.x = temp.x; hittest.pt.y = temp.y; uSendMessage(wnd_header, HDM_HITTEST, 0, (LPARAM)&hittest); enum { IDM_ASC = 1, IDM_DES = 2, IDM_SEL_ASC, IDM_SEL_DES, IDM_AUTOSIZE, IDM_PREFS, IDM_EDIT_COLUMN, IDM_CUSTOM_BASE }; HMENU menu = CreatePopupMenu(); HMENU selection_menu = CreatePopupMenu(); if (!(hittest.flags & HHT_NOWHERE)) { uAppendMenu(menu, (MF_STRING), IDM_ASC, "&Sort ascending"); uAppendMenu(menu, (MF_STRING), IDM_DES, "Sort &descending"); uAppendMenu(selection_menu, (MF_STRING), IDM_SEL_ASC, "Sort a&scending"); uAppendMenu(selection_menu, (MF_STRING), IDM_SEL_DES, "Sort d&escending"); uAppendMenu(menu, MF_STRING | MF_POPUP, (UINT)selection_menu, "Se&lection"); uAppendMenu(menu, (MF_SEPARATOR), 0, ""); uAppendMenu(menu, (MF_STRING), IDM_EDIT_COLUMN, "&Edit this column"); uAppendMenu(menu, (MF_SEPARATOR), 0, ""); uAppendMenu(menu, (MF_STRING | (cfg_nohscroll ? MF_CHECKED : MF_UNCHECKED)), IDM_AUTOSIZE, "&Auto-sizing columns"); uAppendMenu(menu, (MF_STRING), IDM_PREFS, "&Preferences"); uAppendMenu(menu, (MF_SEPARATOR), 0, ""); pfc::string8 playlist_name; static_api_ptr_t<playlist_manager> playlist_api; playlist_api->activeplaylist_get_name(playlist_name); pfc::string8_fast_aggressive filter, name; int s, e = columns.get_count(); for (s = 0; s<e; s++) { bool add = false; switch (columns[s]->filter_type) { case FILTER_NONE: { add = true; break; } case FILTER_SHOW: { if (wildcard_helper::test(playlist_name, columns[s]->filter, true)) { add = true; /* g_columns.get_string(s, name, STRING_NAME); uAppendMenu(menu,MF_STRING|MF_CHECKED,IDM_CUSTOM_BASE+s,name);*/ } } break; case FILTER_HIDE: { if (!wildcard_helper::test(playlist_name, columns[s]->filter, true)) { add = true; /* g_columns.get_string(s, name, STRING_NAME); uAppendMenu(menu,MF_STRING|MF_CHECKED,IDM_CUSTOM_BASE+s,name);*/ } } break; } if (add) { uAppendMenu(menu, MF_STRING | (columns[s]->show ? MF_CHECKED : MF_UNCHECKED), IDM_CUSTOM_BASE + s, columns[s]->name); } } } else { uAppendMenu(menu, (MF_STRING | (cfg_nohscroll ? MF_CHECKED : MF_UNCHECKED)), IDM_AUTOSIZE, "&Auto-sizing columns"); uAppendMenu(menu, (MF_STRING), IDM_PREFS, "&Preferences"); } menu_helpers::win32_auto_mnemonics(menu); int cmd = TrackPopupMenu(menu, TPM_RIGHTBUTTON | TPM_NONOTIFY | TPM_RETURNCMD, pt.x, pt.y, 0, wnd, 0); DestroyMenu(menu); if (cmd == IDM_ASC) { g_set_sort(hittest.iItem, false); } else if (cmd == IDM_DES) { g_set_sort(hittest.iItem, true); } else if (cmd == IDM_SEL_ASC) { g_set_sort(hittest.iItem, false, true); } else if (cmd == IDM_SEL_DES) { g_set_sort(hittest.iItem, true, true); } else if (cmd == IDM_EDIT_COLUMN) { g_set_tab("Columns"); cfg_cur_prefs_col = g_cache.active_column_active_to_actual(hittest.iItem); //get_idx static_api_ptr_t<ui_control>()->show_preferences(columns::config_get_playlist_view_guid()); } else if (cmd == IDM_AUTOSIZE) { cfg_nohscroll = cfg_nohscroll == 0; update_all_windows(); pvt::ng_playlist_view_t::g_on_autosize_change(); } else if (cmd == IDM_PREFS) { static_api_ptr_t<ui_control>()->show_preferences(columns::config_get_main_guid()); } else if (cmd >= IDM_CUSTOM_BASE) { if (t_size(cmd - IDM_CUSTOM_BASE) < columns.get_count()) { columns[cmd - IDM_CUSTOM_BASE]->show = !columns[cmd - IDM_CUSTOM_BASE]->show; //g_columns //if (!cfg_nohscroll) g_save_columns(); //g_cache.flush_all(); g_reset_columns(); update_all_windows(); pvt::ng_playlist_view_t::g_on_columns_change(); } } return 0; } else if ((HWND)wp == wnd) { //DWORD mp = GetMessagePos(); POINT px, pt = { GET_X_LPARAM(lp), GET_Y_LPARAM(lp) }; static_api_ptr_t<playlist_manager> playlist_api; if (playlist_api->activeplaylist_get_selection_count(1) > 0 && 1) { if (pt.x == -1 && pt.y == -1) { int focus = playlist_api->activeplaylist_get_focus_item(); unsigned last = get_last_viewable_item(); if (focus == -1 || focus < scroll_item_offset || focus > last) { px.x = 0; px.y = 0; } else { RECT rc; get_playlist_rect(&rc); px.x = 0; unsigned item_height = get_item_height(); px.y = (focus - scroll_item_offset)*(item_height)+item_height / 2 + rc.top; } pt = px; MapWindowPoints(wnd, HWND_DESKTOP, &pt, 1); } else { px = pt; ScreenToClient(wnd, &px); //int idx = hittest_item(px.x, px.y); //if (!is_visible(idx)) // SendMessage(wnd_playlist, WM_VSCROLL, MAKEWPARAM(SB_LINEDOWN, 0),0); } // int idx = hittest_item(px.x, px.y); enum { ID_PLAY = 1, ID_CUT, ID_COPY, ID_PASTE, ID_SELECTION, ID_CUSTOM_BASE = 0x8000 }; HMENU menu = CreatePopupMenu();//LoadMenu(core_api::get_my_instance(),MAKEINTRESOURCE(IDR_TREEPOPUP)); service_ptr_t<mainmenu_manager> p_manager_selection; service_ptr_t<contextmenu_manager> p_manager_context; p_manager_selection = standard_api_create_t<mainmenu_manager>(); contextmenu_manager::g_create(p_manager_context); if (p_manager_selection.is_valid()) { p_manager_selection->instantiate(mainmenu_groups::edit_part2_selection); p_manager_selection->generate_menu_win32(menu, ID_SELECTION, ID_CUSTOM_BASE - ID_SELECTION, standard_config_objects::query_show_keyboard_shortcuts_in_menus() ? contextmenu_manager::FLAG_SHOW_SHORTCUTS : 0); if (GetMenuItemCount(menu) > 0) uAppendMenu(menu, MF_SEPARATOR, 0, ""); } AppendMenu(menu, MF_STRING, ID_CUT, L"Cut"); AppendMenu(menu, MF_STRING, ID_COPY, L"Copy"); if (playlist_utils::check_clipboard()) AppendMenu(menu, MF_STRING, ID_PASTE, L"Paste"); AppendMenu(menu, MF_SEPARATOR, 0, NULL); if (p_manager_context.is_valid()) { const keyboard_shortcut_manager::shortcut_type shortcuts[] = { keyboard_shortcut_manager::TYPE_CONTEXT_PLAYLIST, keyboard_shortcut_manager::TYPE_CONTEXT }; p_manager_context->set_shortcut_preference(shortcuts, tabsize(shortcuts)); p_manager_context->init_context_playlist(standard_config_objects::query_show_keyboard_shortcuts_in_menus() ? contextmenu_manager::FLAG_SHOW_SHORTCUTS : 0); p_manager_context->win32_build_menu(menu, ID_CUSTOM_BASE, -1); } menu_helpers::win32_auto_mnemonics(menu); MENU_A_BASE = ID_SELECTION; MENU_B_BASE = ID_CUSTOM_BASE; g_main_menu_a = p_manager_selection; g_main_menu_b = p_manager_context; int cmd = TrackPopupMenu(menu, TPM_RIGHTBUTTON | TPM_NONOTIFY | TPM_RETURNCMD, pt.x, pt.y, 0, wnd, 0); if (m_status_override.is_valid()) { m_status_override.release(); } DestroyMenu(menu); if (cmd) { if (cmd == ID_CUT) { playlist_utils::cut(); } else if (cmd == ID_COPY) { playlist_utils::copy(); } else if (cmd == ID_PASTE) { playlist_utils::paste(wnd); } else if (cmd >= ID_SELECTION && cmd<ID_CUSTOM_BASE) { if (p_manager_selection.is_valid()) { p_manager_selection->execute_command(cmd - ID_SELECTION); } } else if (cmd >= ID_CUSTOM_BASE) { if (p_manager_context.is_valid()) { p_manager_context->execute_by_id(cmd - ID_CUSTOM_BASE); } } } g_main_menu_a.release(); g_main_menu_b.release(); } // contextmenu_manager::win32_run_menu_context_playlist(wnd, 0, config_object::g_get_data_bool_simple(standard_config_objects::bool_show_keyboard_shortcuts_in_menus, true) ? contextmenu_manager::FLAG_SHOW_SHORTCUTS : 0); } } return 0; //#ifdef INLINE_EDIT case WM_PARENTNOTIFY: { if (wp == WM_DESTROY) { if (m_wnd_edit && (HWND)lp == m_wnd_edit) m_wnd_edit = 0; } } break; case MSG_KILL_INLINE_EDIT: exit_inline_edit(); return 0; #if 1 case WM_COMMAND: switch (wp) { case (EN_CHANGE << 16) | 667: { m_edit_changed = true; } break; } break; #endif case WM_TIMER: { if (wp == EDIT_TIMER_ID) { create_inline_edit_v2(m_edit_index, m_edit_column); if (m_edit_timer) { KillTimer(wnd_playlist, EDIT_TIMER_ID); m_edit_timer = false; } return 0; } } break; //#endif case WM_NOTIFY: switch (((LPNMHDR)lp)->idFrom) { case ID_PLAYLIST_TOOLTIP: switch (((LPNMHDR)lp)->code) { case TTN_SHOW: RECT rc, rc_tt; rc = tooltip; GetWindowRect(g_tooltip, &rc_tt); int offset = MulDiv(get_item_height() - rc_tt.bottom + rc_tt.top, 1, 2); rc.top += offset; SetWindowPos(g_tooltip, NULL, rc.left, rc.top, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE); return TRUE; } break; case 5001: switch (((LPNMHDR)lp)->code) { case HDN_BEGINTRACKA: case HDN_BEGINTRACKW: { return (cfg_nohscroll ? TRUE : FALSE); } case HDN_ENDDRAG: { if (((LPNMHEADERA)lp)->iButton == 0) { if (((LPNMHEADERA)lp)->pitem && (((LPNMHEADERA)lp)->pitem->mask & HDI_ORDER)) { int from = ((LPNMHEADERA)lp)->iItem; int to = ((LPNMHEADERA)lp)->pitem->iOrder; if (to >= 0 && from != to) { int act_from = g_cache.active_column_active_to_actual(from), act_to = g_cache.active_column_active_to_actual(to); columns.move(act_from, act_to); //if (!cfg_nohscroll) g_save_columns(); g_reset_columns(); update_all_windows(); pvt::ng_playlist_view_t::g_on_columns_change(); } } else { } } return (TRUE); } case HDN_DIVIDERDBLCLICK: if (!cfg_nohscroll) { static_api_ptr_t<playlist_manager> playlist_api; HDC hdc; hdc = GetDC(wnd_playlist); int size; pfc::string8 text; SelectObject(hdc, g_font); int w = 0, n, t = playlist_api->activeplaylist_get_item_count(); for (n = 0; n<t; n++) { // playlist_api->format_title(n, text, g_playlist_entries.get_display_spec(((LPNMHEADER)lp)->iItem), NULL); g_cache.active_get_display_name(n, ((LPNMHEADER)lp)->iItem, text); size = ui_helpers::get_text_width_color(hdc, text, text.length()); if (size > w) w = size; } // g_playlist_entries.get_column(((LPNMHEADER)lp)->iItem)->_set_width(w+5); columns[g_cache.active_column_active_to_actual(((LPNMHEADER)lp)->iItem)]->width = w + 15; ReleaseDC(wnd_playlist, hdc); update_all_windows(); g_save_columns(); pvt::ng_playlist_view_t::g_on_column_widths_change(); } return 0; case HDN_ITEMCLICK: { bool des = false; static_api_ptr_t<playlist_manager> playlist_api; unsigned col; bool descending; bool sorted = g_cache.active_get_playlist_sort(col, &descending); if (sorted && col == ((LPNMHEADER)lp)->iItem) des = !descending; g_set_sort(((LPNMHEADER)lp)->iItem, des /*, playlist_api->activeplaylist_get_selection_count(1) && cfg_sortsel != 0*/); } break; case HDN_ITEMCHANGED: { if (!cfg_nohscroll) { if (((LPNMHEADER)lp)->pitem->mask & HDI_WIDTH) columns[g_cache.active_column_active_to_actual(((LPNMHEADER)lp)->iItem)]->width = ((LPNMHEADER)lp)->pitem->cxy; update_all_windows(wnd_header); g_save_columns(); pvt::ng_playlist_view_t::g_on_column_widths_change(); } } break; } break; } } return uDefWindowProc(wnd, msg, wp, lp); }