EXTERN int Nap_Polyline( NapClientData *nap_cd, int *px, /* x polygon points */ int *py, /* y polygon points */ size_t n, /* number of polygon points */ float *dataPtr, /* place to draw line */ float value, /* value to write line */ size_t x_dim, /* x dimension size */ size_t y_dim, /* y dimension size */ int close) /* Close the polygon? */ { size_t i; /* counter */ int status; /* error code */ for(i = 1; i < n; i++) { status = Nap_DrawLine(nap_cd, px[i-1], py[i-1], px[i], py[i], dataPtr, value, x_dim, y_dim); CHECK2(status == TCL_OK, "Nap_Polyline: error calling Nap_DrawLine"); } if(close) { status = Nap_DrawLine(nap_cd, px[n-1], py[n-1], px[0], py[0], dataPtr, value, x_dim, y_dim); CHECK2(status == TCL_OK, "Nap_Polyline: error calling Nap_DrawLine"); } return TCL_OK; }
static void *dongle_f(void *arg) { struct dongle_struct *ds = arg; rtlsdr_dev_t *dev = NULL; fprintf(stderr, "Initializing %d\n", ds->id); #ifdef PURKKA1 CHECK1(rtlsdr_open(&dev, (ds->id + 1) % 3)); #define trigger_id 2 #else CHECK1(rtlsdr_open(&dev, ds->id)); #define trigger_id 0 #endif ds->dev = dev; CHECK1(rtlsdr_set_sample_rate(dev, samprate)); CHECK1(rtlsdr_set_dithering(dev, 0)); CHECK1(rtlsdr_set_center_freq(dev, frequency)); CHECK1(rtlsdr_set_tuner_gain_mode(dev, 1)); CHECK1(rtlsdr_set_tuner_gain(dev, gain)); CHECK1(rtlsdr_reset_buffer(dev)); fprintf(stderr, "Initialized %d\n", ds->id); donglesok++; for(;;) { int task; pthread_mutex_lock(&dongle_m); if(dongle_task == DONGLE_EXIT) break; sem_post(&dongle_sem); pthread_cond_wait(&dongle_c, &dongle_m); task = dongle_task; pthread_mutex_unlock(&dongle_m); if(task == DONGLE_READ) { int ret; int blocksize = ds->blocksize, n_read = 0; n_read = 0; errno = 0; CHECK2(ret = rtlsdr_read_sync(dev, ds->buffer, blocksize, &n_read)); if(ret < 0) { } else if(n_read < blocksize) { fprintf(stderr, "Short read %d: %d/%d\n", ds->id, n_read, blocksize); } else if(coherent_debug) { fprintf(stderr, "Read %d\n", ds->id); } } else if(task == DONGLE_EXIT) break; } donglesok--; err: fprintf(stderr, "Exiting %d\n", ds->id); if(dev) CHECK2(rtlsdr_close(dev)); sem_post(&dongle_sem); return NULL; }
static int FileWriteNAO( Tcl_Interp *interp, CONST char *naoName, Tcl_Obj *format, Tk_PhotoImageBlock *blockPtr) { register long w, h,pixelSize; long greenOffset, blueOffset; unsigned char *pixelPtr, *pixLinePtr; char *str; Nap_NAO *naoPtr; size_t shape[3]; register Nap_u8 *red,*green,*blue; NapClientData *nap_cd = Nap_GetClientData(interp); shape[0] = 3; shape[1] = blockPtr->height; shape[2] = blockPtr->width; naoPtr = Nap_NewNAO(nap_cd, NAP_U8, 3, shape); CHECK2(naoPtr,"FileWriteNAO: error calling Nap_NewNAO"); str = Nap_Assign(nap_cd, (char *) naoName, naoPtr->id); CHECK2(str,"FileWriteNAO: error calling Nap_Assign"); pixLinePtr = blockPtr->pixelPtr + blockPtr->offset[0]; greenOffset = blockPtr->offset[1] - blockPtr->offset[0]; blueOffset = blockPtr->offset[2] - blockPtr->offset[0]; red = naoPtr->data.U8; green = red + shape[1]*shape[2]; blue = green + shape[1]*shape[2]; /* red,green,blue,red,green,blue,red.... */ /* * Terribly inefficient write process */ pixelSize = blockPtr->pixelSize; for (h = blockPtr->height; h > 0; h--) { pixelPtr = pixLinePtr; for (w = blockPtr->width; w > 0; w--) { *red = pixelPtr[0]; *green = pixelPtr[greenOffset]; *blue = pixelPtr[blueOffset]; pixelPtr = pixelPtr + pixelSize; red++; green++; blue++; } pixLinePtr = pixLinePtr + blockPtr->pitch; } return TCL_OK; }
static void check_widget_rect( LCUI_SysEvent ev, void *arg ) { int ret = 0; LCUI_RectF rectf; LCUI_Rect rect, old_rect; LCUI_Rect *paint_rect = &ev->paint.rect; rectf.x = self.x; rectf.y = self.y; rectf.width = WIDGET_WIDTH; rectf.height = WIDGET_WIDTH; LCUIMetrics_ComputeRectActual( &old_rect, &rectf ); LCUIMetrics_ComputeRectActual( &rect, &self.widget->box.canvas ); LCUIRect_MergeRect( &rect, &rect, &old_rect ); CHECK2( check_rect_correct( &rect, paint_rect ) ); if( ret != 0 ) { TEST_LOG( "[%d] correct: (%d, %d, %d, %d)," " actual: (%d, %d, %d, %d)\n", self.step, rect.x, rect.y, rect.width, rect.height, paint_rect->x, paint_rect->y, paint_rect->width, paint_rect->height ); } else { self.pass += 1; } self.count += 1; self.x = self.widget->x; self.y = self.widget->y; LCUI_PostSimpleTask( test_move_widget, NULL, NULL ); }
static int napFillPolygon( NapClientData *nap_cd, struct PointListHeader *VertexList, /* Polygon points */ int XOffset, /* offsets to x values */ int YOffset) /* ofset to y values */ { struct EdgeState *EdgeTableBuffer; int CurrentY; /* * It takes a minimum of 3 vertices to cause any pixels to be * drawn; reject polygons that are guaranteed to be invisible * In this case nap_PolyLine will draw, nothing, a point or a line. */ if(VertexList->Length < 3) { return TCL_OK; } /* * Get enough memory to store the entire edge table */ if((EdgeTableBuffer = (struct EdgeState *) (NAP_ALLOC(nap_cd, sizeof(struct EdgeState) * VertexList->Length))) == NULL) { CHECK2(0, "napFillPolygon: Couldn't get memory for the edge table"); } /* * Build the global edge table */ napBuildGET(VertexList, EdgeTableBuffer, XOffset, YOffset); /* * Scan down through the polygon edges, one scan line at a time, * so long as at least one edge remains in either the GET or AET */ AETPtr = NULL; /* initialize the active edge table to empty */ CurrentY = GETPtr->StartY; /* start at the top polygon vertex */ while ((GETPtr != NULL) || (AETPtr != NULL)) { napMoveXSortedToAET(CurrentY); /* update AET for this scan line */ napScanOutAET(nap_cd, CurrentY); /* draw this scan line from AET */ napAdvanceAET(); /* advance AET edges 1 scan line */ napXSortAET(); /* resort on X */ CurrentY++; /* advance to the next scan line */ } /* * Release the memory we've allocated and we're done */ NAP_FREE(nap_cd, EdgeTableBuffer); return TCL_OK; }
int main4() { int cnt = 1000000; start_pres_server(); struct sched_pres *sp = (struct sched_pres*)buf; uint8 no = 0; while(1) { INFO("\033[1;33mtcp server... main4\033[0m \n"); if(!is_client_connected() && !have_packet()) { no = 0; DEBUG("no client!\n"); usleep(1000000); } if(have_packet()) { int len = get_packet(buf, MAX_LEN); CHECK2(len >=23 && len == sp->pkt_len); INFO("Get a packet!\n dst_tel_code:%x\nsrc_tel_code:%x\n" "pkt_len:%d\nno%d\ntime:%s\ndata_type:%x\ndata_sub_type:%x\n" "test_len:%d\n", sp->dst_tel_code, sp->src_tel_code, sp->pkt_len, sp->no, ctime(&sp->time), sp->data_type, sp->data_sub_type, sp->text_len); int i; uint8 c = 0; no++; // DEBUG("should no:%d RECV_NO:%d\n", no, sp->no); // CHECK2(no==sp->no); for(i = 0; i < sp->text_len; i++) { if(sp->data[i] != c) { DEBUG("i = %d sp->data[i]==%d c==%d\n", i, sp->data[i], c); CHECK2(sp->data[i]==c); } c++; } } usleep(10000); } stop_pres_server(); }
int main() { CHECK2(pthread_create(&tid1, NULL, thread1, NULL) == 0); //CHECK2(pthread_create(&tid2, NULL, thread2, NULL) == 0); //CHECK2(pthread_create(&tid3, NULL, thread3, NULL) == 0); pthread_join(tid1, NULL); //pthread_join(tid2, NULL); //pthread_join(tid3, NULL); }
static int GameStatusToReturnCode() { CHECK2((game_status & flag_quit) == 0, "status: %x", game_status); if (game_status & flag_mated) { return R_CHECKMATE; } if (game_status & flag_drawn) { return R_DRAW; } if (game_status & flag_resigned) { return R_RESIGNED; } return R_OK; }
static int ParseCsaMove(JNIEnv* env, jstring jmove_str, unsigned int* move, MoveBuf move_str) { const char* tmp = (*env)->GetStringUTFChars(env, jmove_str, NULL); CHECK(tmp != NULL); CHECK2(strlen(tmp) < sizeof(MoveBuf) - 1, "move: %s", tmp); strcpy(move_str, tmp); int r = interpret_CSA_move(&tree, move, move_str); if (r < 0) { LOG_DEBUG("Failed to parse move: %s: %s", move_str, str_error); } (*env)->ReleaseStringUTFChars(env, jmove_str, tmp); return r; }
EXTERN int Nap_Polyfill( NapClientData *nap_cd, int *px, /* polygon x values */ int *py, /* polygon y values */ size_t n, /* number of polygon points */ float *dataPtr, /* pointer to data start */ float fill, /* polygon draw value */ size_t x_dim, /* x dimension of data */ size_t y_dim) /* y dimension of data */ { typedef struct Point point; typedef struct PointListHeader polygon; point *xyPtr; polygon *Polygon; int status; int i; status = Nap_Polyline(nap_cd, px,py,n,dataPtr,fill, x_dim, y_dim, 1); CHECK(status == TCL_OK); status = Nap_InitFill(fill,fill,dataPtr,x_dim,y_dim); CHECK2(status == TCL_OK, "Nap_Polyfill: error calling Nap_InitFill"); xyPtr = (point *)NAP_ALLOC(nap_cd, sizeof(point)*n); Polygon = (polygon *)NAP_ALLOC(nap_cd, sizeof(polygon)); for(i=0; i < n; i++) { xyPtr[i].X = px[i]; xyPtr[i].Y = py[i]; } Polygon->Length = n; Polygon->PointPtr = xyPtr; status = napFillPolygon(nap_cd, Polygon,0,0); CHECK(status == TCL_OK); NAP_FREE(nap_cd, xyPtr); NAP_FREE(nap_cd, Polygon); return(TCL_OK); }
int test_main(int, char*[]) { // An all-blank string is treated as zero. { int const n = 9; double const d[n] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; std::string e(" "); CHECK0(d, n, e); } // Make sure example in comment at top works. // 1 3; 7 5;0; --> 1 1 1 7 7 0... { int const n = 9; double const d[n] = {1, 1, 1, 7, 7, 0, 0, 0, 0}; std::string e("1 3; 7 5;0"); CHECK0(d, n, e); } // Numbers separated by semicolons mean values; the last is // replicated to fill the vector. { int const n = 5; double const d[n] = {1, 2, 3, 3, 3}; std::string e("1; 2; 3"); CHECK0(d, n, e); } // Number-pairs separated by semicolons mean {value, end-duration}. { int const n = 10; double const d[n] = {1, 1, 1, 3, 3, 3, 5, 5, 5, 7}; std::string e("1 3; 3 6; 5 9; 7"); CHECK0(d, n, e); } // {value, @ attained_age} { int const n = 10; double const d[n] = {1, 1, 1, 3, 3, 3, 5, 5, 5, 7}; std::string e("1 @93; 3 @96; 5 @99; 7"); CHECK0(d, n, e); } // {value, # number_of_years_since_last_interval_endpoint} { int const n = 10; double const d[n] = {1, 1, 1, 3, 3, 3, 5, 5, 5, 7}; std::string e("1 #3; 3 #3; 5 #3; 7"); CHECK0(d, n, e); } // {value [|( begin-duration, end-duration ]|) } // Test [x,y). { int const n = 9; double const d[n] = {1, 1, 3, 3, 3, 5, 7, 7, 7}; std::string e("1 [0, 2); 3 [2, 5); 5 [5, 6); 7"); CHECK0(d, n, e); } // Test (x,y]. { int const n = 9; double const d[n] = {1, 1, 1, 3, 3, 3, 5, 7, 7}; std::string e("1; 1 (0, 2]; 3 (2, 5]; 5 (5, 6]; 7"); CHECK0(d, n, e); } // Test a mixture of all five ways of specifying duration. { int const n = 9; double const d[n] = {1, 1, 1, 1, 2, 3, 4, 5, 5}; std::string e("1 [0, 4); 2 5; 3 #1; 4 @97; 5"); CHECK0(d, n, e); } // Test intervals of length one. { int const n = 5; double const d[n] = {1, 3, 5, 7, 7}; std::string e("1 [0, 1); 3 [1, 2); 5 (1, 2]; 7"); CHECK0(d, n, e); } // Test empty intervals. { int const n = 5; double const d[n] = {1, 3, 5, 7, 7}; std::string e("1 [0, 1); 3 [1, 1]; 5 (1, 2]; 7"); CHECK0(d, n, e); } // Test subtly improper intervals. { int const n = 5; double const d[n] = {0, 0, 0, 0, 0}; std::string e("1 [0, 0); 3 (1, 2); 5 (2, 2]; 7"); CHECK0(d, n, e); } // Test grossly improper intervals. { int const n = 9; double const d[n] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; std::string e("1; 9 (2, 0]; 3 [7, 3); 5 (5, 5); 7"); CHECK0(d, n, e); } // Test intervals with 'holes'. Since the last element is replicated, // there can be no 'hole' at the end. { int const n = 9; double const d[n] = {0, 1, 0, 3, 0, 5, 7, 7, 7}; std::string e("1 [1, 2); 3 [3, 3]; 5 (4, 5]; 7"); CHECK0(d, n, e); } // Test overlapping intervals. // TODO ?? Treat these as an error? { int const n = 9; double const d[n] = {1, 1, 1, 3, 3, 5, 5, 7, 7}; std::string e("1; 1 (0, 8]; 3 (2, 7]; 5 (4, 6]; 7"); CHECK0(d, n, e); } // Test intervals with decreasing begin-points. // TODO ?? Should this case be allowed? { int const n = 9; double const d[n] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; std::string e("5 [5, 6); 3 [2, 5); 1 [0, 2); 7"); CHECK0(d, n, e); } // Durations with '@' prefix mean attained age. { int const n = 10; double const d[n] = {0, 12, 0, 27, 0, 1, 7, 7, 7, 7}; std::string e("12 [1, @92); 27 [@93, @93]; 1 (@94, 5]; 7"); CHECK0(d, n, e); } // Test floating-point values; we choose values that we know // must be exactly representable on a binary machine, so that a // simple test for equality suffices. { int const n = 10; double const d[n] = {0, 12.25, 0, 27.875, 0, 1.0625, 7.5, 7.5, 7.5, 7.5}; std::string e("12.25 [1, @92); 27.875 [@93, @93]; 1.0625 (@94, 5]; 7.5"); CHECK0(d, n, e); } // {value, @ age} means {value, to-attained-age} { int const n = 10; double const d[n] = {1, 1, 1, 3, 3, 3, 5, 5, 5, 7}; std::string e("1 @93; 3 @96; 5 @99; 7"); CHECK0(d, n, e); } // TODO ?? Also support and test: // additive expressions e.g. retirement-10 ? // Test construction from vector. // 1 1 1 2 2 --> 1 [0,3);2 [3,5) // TODO ?? Test against canonical representation once we define that. { int const n = 5; double const d[n] = {1, 1, 1, 2, 2}; std::vector<double> v(d, d + n); BOOST_TEST(v == InputSequence(v).linear_number_representation()); } // Test (enumerative) extra keywords. { int const n = 9; char const* c[n] = {"a", "a", "ccc", "ccc", "b", "b", "b", "b", "b"}; double const d[n] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; std::string e("a[0, 2); ccc [2, 4);b[4, 6);"); std::vector<std::string> k; k.push_back("not_used"); k.push_back("a"); k.push_back("b"); k.push_back("c"); k.push_back("cc"); k.push_back("ccc"); CHECK1(d, n, e, k, c); } // Test numbers mixed with (enumerative) extra keywords. { int const n = 9; char const* c[n] = {"", "", "keyword_00", "keyword_00", "", "", "", "", ""}; double const d[n] = {1, 1, 0, 0, 5, 5, 7, 7, 7}; std::string e("1 [0, 2); keyword_00 [2, 4); 5 [4, 6); 7"); std::vector<std::string> k; k.push_back("keyword_00"); CHECK1(d, n, e, k, c); } // Test numbers mixed with (enumerative) extra keywords, with // a default keyword. { int const n = 10; char const* c[n] = {"b", "b", "x", "a", "x", "x", "a", "x", "x", "x"}; double const d[n] = { 0, 0, 0, 0, 5, 5, 0, 7, 7, 7}; std::string e("b [0, 2); a [3, 4); 5 [4, 6); a; 7"); std::vector<std::string> k; k.push_back("a"); k.push_back("b"); k.push_back("x"); std::string w("x"); CHECK2(d, n, e, k, c, w); } // TODO ?? Also test keyword as scalar duration. // Duration keywords: {retirement, maturity} { int const n = 10; double const d[n] = {7, 7, 7, 7, 7, 4, 4, 4, 4, 4}; std::string e("7, retirement; 4"); CHECK0(d, n, e); InputSequence seq("7, retirement; 4", 10, 90, 95, 0, 2002, 0); std::vector<ValueInterval> const& i(seq.interval_representation()); BOOST_TEST(e_inception == i[0].begin_mode); BOOST_TEST(e_retirement == i[0].end_mode ); BOOST_TEST(e_retirement == i[1].begin_mode); BOOST_TEST(e_maturity == i[1].end_mode ); } // TODO ?? Also test default keyword. // TODO ?? Also test keywords-only switch. return 0; }
static int Nap_DrawLine( NapClientData *nap_cd, int x1, /* first x coordinate */ int y1, /* first y coordinate */ int x2, /* second x coordinate */ int y2, /* second y coordinate */ float *dataPtr, /* place to draw line */ float value, /* value to write line */ size_t x_dim, /* x dimension size */ size_t y_dim) /* y dimension size */ { int xt; /* temporary x value */ int yt; /* temporary y value */ int dx; /* x difference (x2 - x1) */ int dy; /* y difference (y2 - y1) */ int x; /* x position */ int y; /* y position */ int yincr; /* increment in y direction */ int xincr; /* increment in x direction */ int aincr; /* increment in y direction */ int bincr; /* increment in y direction */ int d; /* variable */ float *pixelPtr; /* place to write value */ float *maxPtr; /* upper limit on the pointer address */ maxPtr = dataPtr + x_dim * y_dim; /* * First decide if we should increment x or y! */ if (abs(x2 - x1) >= abs(y2 - y1)) { /* * Force x1 < x2 */ if (x1 > x2) { xt = x1; x1 = x2; x2 = xt; yt = y1; y1 = y2; y2 = yt; } if (y2 > y1) { yincr = 1; } else { yincr = -1; } dx = x2 - x1; dy = abs(y2 - y1); d = 2 * dy - dx; aincr = 2 * (dy - dx); bincr = 2 * dy; x = x1; y = y1; /* * Locate and set the value of the first pixel in the line */ pixelPtr = dataPtr + x_dim * y + x; CHECK4((pixelPtr >= dataPtr) && (pixelPtr <= maxPtr), "attempt to draw a pixel outside the data area %d,%d",x,y); /* * Setting a float pixel value */ *pixelPtr = value; for(x = x1+1; x <= x2; x++) { if(d >= 0) { y = y + yincr; d = d + aincr; } else { d = d + bincr; } /* * Setting a float pixel value */ pixelPtr = dataPtr + x_dim * y + x; CHECK2((pixelPtr >= dataPtr) && (pixelPtr <= maxPtr), "attempt to draw a pixel outside the data area"); *pixelPtr = value; } } else { /* * Force y1 < y2 */ if (y1 > y2) { xt = x1; x1 = x2; x2 = xt; yt = y1; y1 = y2; y2 = yt; } if (x2 > x1) { xincr = 1; } else { xincr = -1; } dy = y2 - y1; dx = abs(x2 - x1); d = 2 * dx - dy; aincr = 2 * (dx - dy); bincr = 2 * dx; x = x1; y = y1; /* draw the first pixel */ pixelPtr = dataPtr + x_dim * y + x; CHECK2((pixelPtr >= dataPtr) && (pixelPtr <= maxPtr), "attempt to draw a pixel outside the data area"); *pixelPtr = value; for(y = y1+1; y <= y2; y++) { if(d >= 0) { x = x + xincr; d = d + aincr; } else { d = d + bincr; } /* draw a pixel */ pixelPtr = dataPtr + x_dim * y + x; CHECK2((pixelPtr >= dataPtr) && (pixelPtr <= maxPtr), "attempt to draw a pixel outside the data area"); *pixelPtr = value; } } return TCL_OK; }
static int StringReadNAO( Tcl_Interp *interp, Tcl_Obj *nap_expr, /* string containing NAP expression */ Tcl_Obj *format, /* format string not used */ Tk_PhotoHandle imageHandle, int destX, int destY, int width, int height, int srcX, int srcY) { int naoWidth; int naoHeight; int naoDepth; Nap_NAO *naoPtr; Nap_NAO *naoPtr0; int rank; Tk_PhotoImageBlock block; NapClientData *nap_cd = Nap_GetClientData(interp); naoPtr0 = Nap_GetNaoFromObj(nap_cd, nap_expr); CHECK2(naoPtr0, "StringReadNAO: error calling Nap_GetNaoFromObj"); Nap_IncrRefCount(nap_cd, naoPtr0); naoPtr = Nap_CastNAO(nap_cd, naoPtr0, NAP_U8); Nap_IncrRefCount(nap_cd, naoPtr); Nap_DecrRefCount(nap_cd, naoPtr0); rank = naoPtr->rank; switch (rank) { case 2: naoWidth = naoPtr->shape[1]; naoHeight = naoPtr->shape[0]; break; case 3: naoWidth = naoPtr->shape[2]; naoHeight = naoPtr->shape[1]; naoDepth = naoPtr->shape[0]; break; default: CHECK2(0, "StringReadNAO: Rank is not 1 or 2"); } /* * Setup the dimensions for the display */ if ((srcX + width) > naoWidth) { width = naoWidth - srcX; } if ((srcY + height) > naoHeight) { height = naoHeight - srcY; } if ((width <= 0) || (height <= 0) || (srcX >= naoWidth) || (srcY >= naoHeight)) { return TCL_OK; } /* * Get the output window open to the correct size */ Tk_PhotoExpand(imageHandle, destX + width, destY + height); /* * setup the supporting image data structure */ block.width = naoWidth; block.height = naoHeight; block.pitch = naoWidth; /* Address difference between corresponding * pixels in successive lines */ block.pixelSize = 1; /* Address difference successive pixels * in the same line */ /* Address differences between the red, green * and blue components of the pixel and the * pixel as a whole. */ block.offset[0] = 0; block.offset[1] = 0; block.offset[2] = 0; if (rank == 3) { if(naoDepth >= 3) { block.offset[1] = naoHeight*naoWidth; block.offset[2] = 2 * naoWidth*naoHeight; } else if(naoDepth == 2) { block.offset[2] = naoWidth*naoHeight; } } /* Pointer to the first part of the first pixel */ block.pixelPtr = (unsigned char *) naoPtr->data.U8; Tk_PhotoPutBlock(imageHandle, &block, destX, destY, naoWidth, naoHeight, TK_PHOTO_COMPOSITE_OVERLAY); Nap_DecrRefCount(nap_cd, naoPtr); return TCL_OK; }
QVariant MetaInfoModel::data(const QModelIndex &index, int role) const { if(role == Qt::DisplayRole) { switch(index.row() + m_offset) { case 0: return (!index.column()) ? tr("Full Path") : CHECK1(QDir::toNativeSeparators(m_fullInfo->filePath())); break; case 1: return (!index.column()) ? tr("Format") : CHECK1(m_fullInfo->audioBaseInfo()); break; case 2: return (!index.column()) ? tr("Container") : CHECK1(m_fullInfo->containerInfo()); break; case 3: return (!index.column()) ? tr("Compression") : CHECK1(m_fullInfo->audioCompressInfo()); break; case 4: return (!index.column()) ? tr("Duration") : CHECK1(m_fullInfo->durationInfo()); break; case 5: return (!index.column()) ? tr("Title") : CHECK1(m_metaInfo->title()); break; case 6: return (!index.column()) ? tr("Artist") : CHECK1(m_metaInfo->artist()); break; case 7: return (!index.column()) ? tr("Album") : CHECK1(m_metaInfo->album()); break; case 8: return (!index.column()) ? tr("Genre") : CHECK1(m_metaInfo->genre()); break; case 9: return (!index.column()) ? tr("Year") : CHECK2(m_metaInfo->year()); break; case 10: return (!index.column()) ? tr("Position") : ((m_metaInfo->position() == UINT_MAX) ? tr("Generate from list position") : CHECK2(m_metaInfo->position())); break; case 11: return (!index.column()) ? tr("Comment") : CHECK1(m_metaInfo->comment()); break; default: return QVariant(); break; } } else if(role == Qt::DecorationRole && index.column() == 0) { switch(index.row() + m_offset) { case 0: return QIcon(":/icons/folder_page.png"); break; case 1: return QIcon(":/icons/sound.png"); break; case 2: return QIcon(":/icons/package.png"); break; case 3: return QIcon(":/icons/compress.png"); break; case 4: return QIcon(":/icons/clock_play.png"); break; case 5: return QIcon(":/icons/music.png"); break; case 6: return QIcon(":/icons/user.png"); break; case 7: return QIcon(":/icons/cd.png"); break; case 8: return QIcon(":/icons/star.png"); break; case 9: return QIcon(":/icons/date.png"); break; case 10: return QIcon(":/icons/timeline_marker.png"); break; case 11: return QIcon(":/icons/comment.png"); break; default: return QVariant(); break; } } else if(role == Qt::TextColorRole && index.column() == 1) { switch(index.row() + m_offset) { case 0: return CHECK3(m_fullInfo->filePath()); break; case 1: return CHECK3(m_fullInfo->audioBaseInfo()); break; case 2: return CHECK3(m_fullInfo->containerInfo()); break; case 3: return CHECK3(m_fullInfo->audioCompressInfo()); break; case 4: return CHECK4(m_fullInfo->durationInfo()); break; case 5: return CHECK3(m_metaInfo->title()); break; case 6: return CHECK3(m_metaInfo->artist()); break; case 7: return CHECK3(m_metaInfo->album()); break; case 8: return CHECK3(m_metaInfo->genre()); break; case 9: return CHECK4(m_metaInfo->year()); break; case 10: return CHECK4(m_metaInfo->position()); break; case 11: return CHECK3(m_metaInfo->comment()); break; default: return QVariant(); break; } } else { return QVariant(); } }