void ImageHistoryGraphModel::Private::build() { delete rootItem; vertexItems.clear(); rootItem = new HistoryTreeItem; //kDebug() << historyGraph; HistoryGraph::Vertex ref = graph().findVertexByProperties(info); path = graph().longestPathTouching(ref, sortBy(newestInfoFirst)); categories = graph().categorize(); if (path.isEmpty()) return; if (mode == ImageHistoryGraphModel::ImagesListMode) { buildImagesList(); } else if (mode == ImageHistoryGraphModel::ImagesTreeMode) { buildImagesTree(); } else if (mode == CombinedTreeMode) { buildCombinedTree(ref); } }
/* * @pre Record that caused the overflow already in elements * * @brief Instantiates a new leaf, passes to it the upper * part of its elements, and its level. * * @return new leaf in @newNode param * * @return middle key in return * */ Key* LeafNode::split(Node*& newNode) { newNode = new LeafNode(level); //Leaf has its records ordered by Key[level%dimension] elements = sortBy(level-1); int halfLimit = (elements.size()/2); Key * parentKey = getKeyByLevel(elements.at(halfLimit)->getID(), level-1); int lowLimit = 0; int highLimit = (elements.size()); //finds the best split pivot. lowLimit = findLowLimit(parentKey); //Passes every element with key equal or higher than parent key to newLeaf for(int i = lowLimit; i< highLimit; i++) { newNode->insert(elements[i]); } //Updates space and elements in this leaf for(int i = lowLimit; i< highLimit; i++){ occupiedSpace -= elements[lowLimit]->size(); elements.erase(elements.begin() + lowLimit); } //Updates data numElements = lowLimit; return parentKey; }
void ImageHistoryGraphModel::Private::buildImagesList() { QList<HistoryGraph::Vertex> verticesOrdered = graph().verticesDepthFirstSorted(path.first(), sortBy(oldestInfoFirst)); foreach(const HistoryGraph::Vertex& v, verticesOrdered) { rootItem->addItem(createVertexItem(v)); }
Lesson::Lesson() { model = new QSqlRelationalTableModel(0, SqlConnection::getInstance()->getDatabase()); model->setTable("Lesson"); sortBy(DAY_OF_WEEK); model->setEditStrategy(QSqlTableModel::OnManualSubmit); courseIndex = model->fieldIndex("courseId"); model->setRelation(courseIndex, QSqlRelation("Course", "id", "name")); update(); }
void GridWidget::reset() { ui->showSelected->setChecked(false); ui->searchField->setText(""); countryWidgets.clear(); for (CountryWidget* widget : originalWidgets) { widget->setVisible(true); widget->unselect(); countryWidgets.append(widget); } if (ui->sortBox->currentIndex() != ID) { ui->sortBox->setCurrentIndex(ID); } else { sortBy(ID); } }
void tileMap::pickRowDelta(bool showProgress,Fl_Progress *progress,int alg,int order){ if(currentProject->pal->rowCntPal<=1){ fl_alert("This function needs more than one palette row to work"); return; } if(alg<0){ alg=menuPopupArray(deltaAlgLbl,deltaAlgTooltip,0,deltaChoices); if(alg<0) return; } pushTilemapAll(true); pushTilesAll(tTypeTile); if(order<0){ order=menuPopupArray(deltaAlgLbl,deltaAlgTooltip,0,deltaOrderChoices); if(order<0) return; } if(order>0){ pushPaletteAll(); sortBy(order>3?order-4:order-1,order<4); } unsigned type_temp=palTypeGen; uint8_t tempSet=0; double d[4];//Delta uint32_t di[4];//Delta integer uint32_t x; uint8_t t; uint8_t temp[256];//Just as a word of caution this is used for both sprintf temporary buffer and temporary truecolor tile buffer uint32_t w,h; w=mapSizeW*8; h=mapSizeHA*8; uint8_t * imagein=(uint8_t*)malloc(w*h*4); truecolor_to_image(imagein,-1); uint8_t **imageout=(uint8_t**)malloc(currentProject->pal->rowCntPal*sizeof(void*)); uint32_t xtile=0,ytile=0; if(showProgress){ progress->maximum(currentProject->pal->rowCntPal*3); progress->value(0); } for(x=0;x<currentProject->pal->rowCntPal;++x){//This function has too many hard coded values The four should be a variable with the amount of palette rows if(showProgress){ snprintf((char*)temp,256,"Dithering %d",x); progress->label((char*)temp); Fl::check(); } imageout[x]=(uint8_t*)malloc(w*h*4); truecolor_to_image(imageout[x],-1); if(showProgress){ progress->value((x*3)+1); Fl::check(); } ditherImage(imageout[x],w,h,true,true,true,x); if(showProgress){ progress->value((x*3)+2); Fl::check(); } ditherImage(imageout[x],w,h,true,false,true,x); if(showProgress){ progress->value((x*3)+3); Fl::check(); } } if(showProgress){ progress->maximum(mapSizeHA); progress->label("Picking tiles based on delta"); } unsigned per; if((currentProject->gameSystem==NES)&&(currentProject->subSystem&NES2x2)) per=2; else per=1; for (uint_fast32_t a=0;a<(h*w*4)-(w*4*per);a+=w*4*8*per){//a tiles y for (uint_fast32_t b=0;b<w*4;b+=32*per){//b tiles x if(alg==2||alg==1) memset(di,0,currentProject->pal->rowCntPal*sizeof(uint32_t)); else{ std::fill(d,d+currentProject->pal->rowCntPal,0.); } if ((type_temp != 0) && (currentProject->gameSystem == segaGenesis)){ tempSet=(currentProject->tms->maps[currentProject->curPlane].get_prio(xtile,ytile)^1)*8; set_palette_type_force(tempSet); } for(t=0;t<currentProject->pal->rowCntPal;++t){ for(unsigned c=0;c<per*w*4*8;c+=w*4*8){ for(uint32_t y=0;y<w*4*8;y+=w*4){//pixels y for(unsigned e=0;e<per*32;e+=32){ if(imagein[a+b+y+x+3+c+e]!=0){//Avoid checking transparency switch(alg){ case 0: for(x=0;x<32;x+=4) d[t]+=std::abs(ciede2000rgb(imagein[a+b+y+x+c+e],imagein[a+b+y+x+1+c+e],imagein[a+b+y+x+2+c+e],imageout[t][a+b+y+x+c+e],imageout[t][a+b+y+x+1+c+e],imageout[t][a+b+y+x+2+c+e])); break; case 1: for(x=0;x<32;x+=4) di[t]+=ColourDistance(imagein[a+b+y+x+c+e],imagein[a+b+y+x+1+c+e],imagein[a+b+y+x+2+c+e],imageout[t][a+b+y+x+c+e],imageout[t][a+b+y+x+1+c+e],imageout[t][a+b+y+x+2+c+e]); break; case 3: case 4: case 5: for(x=0;x<32;x+=4){ double h[2],l[2],s[2]; rgbToHsl255(imagein[a+b+y+x+c+e],imagein[a+b+y+x+1+c+e],imagein[a+b+y+x+2+c+e],h,s,l); rgbToHsl255(imageout[t][a+b+y+x+c+e],imageout[t][a+b+y+x+1+c+e],imageout[t][a+b+y+x+2+c+e],h+1,s+1,l+1); d[t]+=std::abs(pickIt(h[0],s[0],l[0],alg-3)-pickIt(h[1],s[1],l[1],alg-3)); } break; default://Usually case 2 for(x=0;x<32;x+=4) di[t]+=sqri(imagein[a+b+y+x+c+e]-imageout[t][a+b+y+x+c+e])+sqri(imagein[a+b+y+x+1+c+e]-imageout[t][a+b+y+x+1+c+e])+sqri(imagein[a+b+y+x+2+c+e]-imageout[t][a+b+y+x+2+c+e]); } } } } } } unsigned sillyrow; if(alg==2||alg==1) sillyrow=pick4Delta(di,currentProject->pal->rowCntPal); else sillyrow=pick4Delta(d,currentProject->pal->rowCntPal); set_pal_row(xtile,ytile,sillyrow); for(unsigned c=0,i=0;c<per*w*4*8;c+=w*4*8,++i){ for(unsigned e=0,j=0;e<per*32;e+=32,++j){ uint_fast32_t truecolor_tile_ptr=0; for (uint_fast32_t y=0;y<w*4*8;y+=w*4){//pixels y memcpy(&temp[truecolor_tile_ptr],&imageout[sillyrow][a+b+y+c+e],32); truecolor_tile_ptr+=32; } currentProject->tileC->truecolor_to_tile_ptr(sillyrow,get_tile(xtile+j,ytile+i),temp,false,false); } } xtile+=per; } if(showProgress){ if((a%(w*4*8*16))==0){ progress->value(ytile); if(window){ window->redraw(); Fl::check(); } } } xtile=0; ytile+=per; } free(imagein); for(unsigned i=0;i<currentProject->pal->rowCntPal;++i) free(imageout[i]); free(imageout); if(currentProject->gameSystem == segaGenesis) set_palette_type(); }
static Htop_Reaction actionSetSortColumn(State* st) { return sortBy(st); }
static void millisleep(unsigned long millisec) { struct timespec req = { .tv_sec = 0, .tv_nsec = millisec * 1000000L }; while(nanosleep(&req,&req)==-1) { continue; } } int main(int argc, char** argv) { int delay = -1; bool userOnly = false; uid_t userId = 0; int usecolors = 1; char *argCopy; char *pid; Hashtable *pidWhiteList = NULL; int opt, opti=0; static struct option long_opts[] = { {"help", no_argument, 0, 'h'}, {"version", no_argument, 0, 'v'}, {"delay", required_argument, 0, 'd'}, {"sort-key", required_argument, 0, 's'}, {"user", required_argument, 0, 'u'}, {"no-color", no_argument, 0, 'C'}, {"no-colour",no_argument, 0, 'C'}, {"pid", required_argument, 0, 'p'}, {0,0,0,0} }; int sortKey = 0; char *lc_ctype = getenv("LC_CTYPE"); if(lc_ctype != NULL) setlocale(LC_CTYPE, lc_ctype); else if ((lc_ctype = getenv("LC_ALL"))) setlocale(LC_CTYPE, lc_ctype); else setlocale(LC_CTYPE, ""); /* Parse arguments */ while ((opt = getopt_long(argc, argv, "hvCs:d:u:p:", long_opts, &opti))) { if (opt == EOF) break; switch (opt) { case 'h': printHelpFlag(); break; case 'v': printVersionFlag(); break; case 's': if (strcmp(optarg, "help") == 0) { for (int j = 1; j < LAST_PROCESSFIELD; j++) printf ("%s\n", Process_fieldNames[j]); exit(0); } sortKey = ColumnsPanel_fieldNameToIndex(optarg); if (sortKey == -1) { fprintf(stderr, "Error: invalid column \"%s\".\n", optarg); exit(1); } break; case 'd': if (sscanf(optarg, "%16d", &delay) == 1) { if (delay < 1) delay = 1; if (delay > 100) delay = 100; } else { fprintf(stderr, "Error: invalid delay value \"%s\".\n", optarg); exit(1); } break; case 'u': if (!setUserOnly(optarg, &userOnly, &userId)) { fprintf(stderr, "Error: invalid user \"%s\".\n", optarg); exit(1); } break; case 'C': usecolors=0; break; case 'p': { argCopy = strdup(optarg); char* saveptr; pid = strtok_r(argCopy, ",", &saveptr); if( !pidWhiteList ) { pidWhiteList = Hashtable_new(8, false); } while( pid ) { unsigned int num_pid = atoi(pid); Hashtable_put(pidWhiteList, num_pid, (void *) 1); pid = strtok_r(NULL, ",", &saveptr); } free(argCopy); break; } default: exit(1); } } if (access(PROCDIR, R_OK) != 0) { fprintf(stderr, "Error: could not read procfs (compiled to look in %s).\n", PROCDIR); exit(1); } int quit = 0; int refreshTimeout = 0; int resetRefreshTimeout = 5; bool doRefresh = true; bool doRecalculate = false; Settings* settings; ProcessList* pl = NULL; UsersTable* ut = UsersTable_new(); #ifdef HAVE_LIBNCURSESW char *locale = setlocale(LC_ALL, NULL); if (locale == NULL || locale[0] == '\0') locale = setlocale(LC_CTYPE, NULL); if (locale != NULL && (strstr(locale, "UTF-8") || strstr(locale, "utf-8") || strstr(locale, "UTF8") || strstr(locale, "utf8"))) CRT_utf8 = true; else CRT_utf8 = false; #endif pl = ProcessList_new(ut, pidWhiteList); Process_getMaxPid(); Header* header = Header_new(pl); settings = Settings_new(pl, header, pl->cpuCount); int headerHeight = Header_calculateHeight(header); // FIXME: move delay code to settings if (delay != -1) settings->delay = delay; if (!usecolors) settings->colorScheme = COLORSCHEME_MONOCHROME; CRT_init(settings->delay, settings->colorScheme); Panel* panel = Panel_new(0, headerHeight, COLS, LINES - headerHeight - 2, false, &Process_class); ProcessList_setPanel(pl, panel); FunctionBar* defaultBar = FunctionBar_new(defaultFunctions, NULL, NULL); setTreeView(pl, defaultBar, pl->treeView); if (sortKey > 0) { pl->sortKey = sortKey; setTreeView(pl, defaultBar, false); pl->direction = 1; } ProcessList_printHeader(pl, Panel_getHeader(panel)); IncSet* inc = IncSet_new(defaultBar); ProcessList_scan(pl); millisleep(75); FunctionBar_draw(defaultBar, NULL); int acc = 0; bool follow = false; struct timeval tv; double oldTime = 0.0; int ch = ERR; int closeTimeout = 0; bool idle = false; bool collapsed = false; while (!quit) { gettimeofday(&tv, NULL); double newTime = ((double)tv.tv_sec * 10) + ((double)tv.tv_usec / 100000); bool recalculate = (newTime - oldTime > settings->delay); int following = follow ? selectedPid(panel) : -1; if (recalculate) { Header_draw(header); oldTime = newTime; } if (doRefresh) { if (recalculate || doRecalculate) { ProcessList_scan(pl); doRecalculate = false; } if (refreshTimeout == 0 || pl->treeView) { ProcessList_sort(pl); refreshTimeout = 1; } ProcessList_rebuildPanel(pl, true, following, userOnly, userId, IncSet_filter(inc)); idle = false; } doRefresh = true; if (pl->treeView) { Process* p = (Process*) Panel_getSelected(panel); if (p) { if (!p->showChildren && !collapsed) { FunctionBar_setLabel(defaultBar, KEY_F(6), "Expand"); FunctionBar_draw(defaultBar, NULL); } else if (p->showChildren && collapsed) { FunctionBar_setLabel(defaultBar, KEY_F(6), "Collap"); FunctionBar_draw(defaultBar, NULL); } collapsed = !p->showChildren; } } if (!idle) { Panel_draw(panel, true); } int prev = ch; if (inc->active) move(LINES-1, CRT_cursorX); ch = getch(); if (ch == ERR) { if (!inc->active) refreshTimeout--; if (prev == ch && !recalculate) { closeTimeout++; if (closeTimeout == 100) { break; } } else closeTimeout = 0; idle = true; continue; } idle = false; if (ch == KEY_MOUSE) { MEVENT mevent; int ok = getmouse(&mevent); if (ok == OK) { if (mevent.bstate & BUTTON1_CLICKED) { if (mevent.y == panel->y) { int x = panel->scrollH + mevent.x + 1; ProcessField field = ProcessList_keyAt(pl, x); if (field == pl->sortKey) { ProcessList_invertSortOrder(pl); setTreeView(pl, defaultBar, false); } else { setSortKey(pl, defaultBar, field, panel, settings); } refreshTimeout = 0; continue; } else if (mevent.y >= panel->y + 1 && mevent.y < LINES - 1) { Panel_setSelected(panel, mevent.y - panel->y + panel->scrollV - 1); doRefresh = false; refreshTimeout = resetRefreshTimeout; follow = true; continue; } if (mevent.y == LINES - 1) { ch = FunctionBar_synthesizeEvent(inc->bar, mevent.x); } } else if (mevent.bstate & BUTTON4_CLICKED) { ch = KEY_UP; #if NCURSES_MOUSE_VERSION > 1 } else if (mevent.bstate & BUTTON5_CLICKED) { ch = KEY_DOWN; #endif } } } if (inc->active) { doRefresh = IncSet_handleKey(inc, ch, panel, getMainPanelValue, NULL); continue; } if (isdigit((char)ch)) { if (Panel_size(panel) == 0) continue; pid_t pid = ch-48 + acc; for (int i = 0; i < ProcessList_size(pl); i++) { Panel_setSelected(panel, i); Process* p = (Process*) Panel_getSelected(panel); if (p && p->pid == pid) { break; } } acc = pid * 10; if (acc > 10000000) acc = 0; continue; } else { acc = 0; } switch (ch) { case KEY_RESIZE: Panel_resize(panel, COLS, LINES-headerHeight-1); IncSet_drawBar(inc); break; case 'M': { refreshTimeout = 0; setSortKey(pl, defaultBar, PERCENT_MEM, panel, settings); break; } case 'T': { refreshTimeout = 0; setSortKey(pl, defaultBar, TIME, panel, settings); break; } case 'c': { Process* p = (Process*) Panel_getSelected(panel); if (!p) break; tagAllChildren(panel, p); break; } case 'U': { for (int i = 0; i < Panel_size(panel); i++) { Process* p = (Process*) Panel_get(panel, i); p->tag = false; } doRefresh = true; break; } case 'P': { refreshTimeout = 0; setSortKey(pl, defaultBar, PERCENT_CPU, panel, settings); break; } case KEY_F(1): case 'h': case '?': { showHelp(pl); FunctionBar_draw(defaultBar, NULL); refreshTimeout = 0; break; } case '\014': // Ctrl+L { clear(); FunctionBar_draw(defaultBar, NULL); refreshTimeout = 0; break; } case ' ': { Process* p = (Process*) Panel_getSelected(panel); if (!p) break; Process_toggleTag(p); Panel_onKey(panel, KEY_DOWN); break; } case 's': { Process* p = (Process*) Panel_getSelected(panel); if (!p) break; TraceScreen* ts = TraceScreen_new(p); TraceScreen_run(ts); TraceScreen_delete(ts); clear(); FunctionBar_draw(defaultBar, NULL); refreshTimeout = 0; CRT_enableDelay(); break; } case 'l': { Process* p = (Process*) Panel_getSelected(panel); if (!p) break; OpenFilesScreen* ts = OpenFilesScreen_new(p); OpenFilesScreen_run(ts); OpenFilesScreen_delete(ts); clear(); FunctionBar_draw(defaultBar, NULL); refreshTimeout = 0; CRT_enableDelay(); break; } case 'S': case 'C': case KEY_F(2): { Setup_run(settings, header); // TODO: shouldn't need this, colors should be dynamic ProcessList_printHeader(pl, Panel_getHeader(panel)); headerHeight = Header_calculateHeight(header); Panel_move(panel, 0, headerHeight); Panel_resize(panel, COLS, LINES-headerHeight-1); FunctionBar_draw(defaultBar, NULL); refreshTimeout = 0; break; } case 'F': { follow = true; continue; } case 'u': { Panel* usersPanel = Panel_new(0, 0, 0, 0, true, Class(ListItem)); Panel_setHeader(usersPanel, "Show processes of:"); UsersTable_foreach(ut, addUserToVector, usersPanel); Vector_insertionSort(usersPanel->items); ListItem* allUsers = ListItem_new("All users", -1); Panel_insert(usersPanel, 0, (Object*) allUsers); const char* fuFunctions[] = {"Show ", "Cancel ", NULL}; ListItem* picked = (ListItem*) pickFromVector(panel, usersPanel, 20, headerHeight, fuFunctions, defaultBar, header); if (picked) { if (picked == allUsers) { userOnly = false; } else { setUserOnly(ListItem_getRef(picked), &userOnly, &userId); } } Panel_delete((Object*)usersPanel); break; } case '+': case '=': case '-': { if (expandCollapse(panel)) { doRecalculate = true; refreshTimeout = 0; } break; } case KEY_F(9): case 'k': { Panel* signalsPanel = (Panel*) SignalsPanel_new(); const char* fuFunctions[] = {"Send ", "Cancel ", NULL}; ListItem* sgn = (ListItem*) pickFromVector(panel, signalsPanel, 15, headerHeight, fuFunctions, defaultBar, header); if (sgn) { if (sgn->key != 0) { Panel_setHeader(panel, "Sending..."); Panel_draw(panel, true); refresh(); foreachProcess(panel, (ForeachProcessFn) Process_sendSignal, (size_t) sgn->key, NULL); napms(500); } } ProcessList_printHeader(pl, Panel_getHeader(panel)); Panel_delete((Object*)signalsPanel); refreshTimeout = 0; break; } #if (HAVE_LIBHWLOC || HAVE_NATIVE_AFFINITY) case 'a': { if (pl->cpuCount == 1) break; Process* p = (Process*) Panel_getSelected(panel); if (!p) break; Affinity* affinity = Process_getAffinity(p); if (!affinity) break; Panel* affinityPanel = AffinityPanel_new(pl, affinity); Affinity_delete(affinity); const char* fuFunctions[] = {"Set ", "Cancel ", NULL}; void* set = pickFromVector(panel, affinityPanel, 15, headerHeight, fuFunctions, defaultBar, header); if (set) { Affinity* affinity = AffinityPanel_getAffinity(affinityPanel); bool ok = foreachProcess(panel, (ForeachProcessFn) Process_setAffinity, (size_t) affinity, NULL); if (!ok) beep(); Affinity_delete(affinity); } Panel_delete((Object*)affinityPanel); ProcessList_printHeader(pl, Panel_getHeader(panel)); refreshTimeout = 0; break; } #endif case KEY_F(10): case 'q': quit = 1; break; case '<': case ',': case '>': case '.': { sortBy(panel, pl, settings, headerHeight, defaultBar, header); refreshTimeout = 0; break; } case KEY_F(18): case KEY_F(6): { if (pl->treeView) { if (expandCollapse(panel)) { doRecalculate = true; refreshTimeout = 0; } } else { sortBy(panel, pl, settings, headerHeight, defaultBar, header); refreshTimeout = 0; } break; } case 'i': { Process* p = (Process*) Panel_getSelected(panel); if (!p) break; IOPriority ioprio = p->ioPriority; Panel* ioprioPanel = IOPriorityPanel_new(ioprio); const char* fuFunctions[] = {"Set ", "Cancel ", NULL}; void* set = pickFromVector(panel, ioprioPanel, 21, headerHeight, fuFunctions, defaultBar, header); if (set) { IOPriority ioprio = IOPriorityPanel_getIOPriority(ioprioPanel); bool ok = foreachProcess(panel, (ForeachProcessFn) Process_setIOPriority, (size_t) ioprio, NULL); if (!ok) beep(); } Panel_delete((Object*)ioprioPanel); ProcessList_printHeader(pl, Panel_getHeader(panel)); refreshTimeout = 0; break; } case 'I': { refreshTimeout = 0; settings->changed = true; ProcessList_invertSortOrder(pl); break; } case KEY_F(8): case '[': { doRefresh = changePriority(panel, 1); break; } case KEY_F(7): case ']': { doRefresh = changePriority(panel, -1); break; } case KEY_F(3): case '/': IncSet_activate(inc, INC_SEARCH); break; case KEY_F(4): case '\\': IncSet_activate(inc, INC_FILTER); refreshTimeout = 0; doRefresh = true; continue; case 't': case KEY_F(5): refreshTimeout = 0; collapsed = false; setTreeView(pl, defaultBar, !pl->treeView); if (pl->treeView) pl->direction = 1; ProcessList_printHeader(pl, Panel_getHeader(panel)); ProcessList_expandTree(pl); settings->changed = true; if (following != -1) continue; break; case 'H': doRecalculate = true; refreshTimeout = 0; pl->hideUserlandThreads = !pl->hideUserlandThreads; pl->hideThreads = pl->hideUserlandThreads; settings->changed = true; break; case 'K': doRecalculate = true; refreshTimeout = 0; pl->hideKernelThreads = !pl->hideKernelThreads; settings->changed = true; break; default: doRefresh = false; refreshTimeout = resetRefreshTimeout; Panel_onKey(panel, ch); break; } follow = false; } attron(CRT_colors[RESET_COLOR]); mvhline(LINES-1, 0, ' ', COLS); attroff(CRT_colors[RESET_COLOR]); refresh(); CRT_done(); if (settings->changed) Settings_write(settings); Header_delete(header); ProcessList_delete(pl); IncSet_delete(inc); FunctionBar_delete((Object*)defaultBar); Panel_delete((Object*)panel); UsersTable_delete(ut); Settings_delete(settings); if(pidWhiteList) { Hashtable_delete(pidWhiteList); } return 0; }