The following commit has been merged in the makelib branch:
commit b7270c1cf6f518750b1cefcfdba416ee42bd7e10
Author: Miriam Ruiz <[email protected]>
Date:   Mon Apr 27 17:52:06 2009 +0200

    Get tags of the proper package in FLTK GUI plugin
    Restructured CLI GUI plugin command input

diff --git a/fltk/pkgbrowser.cpp b/fltk/pkgbrowser.cpp
index cf53685..a31138f 100644
--- a/fltk/pkgbrowser.cpp
+++ b/fltk/pkgbrowser.cpp
@@ -231,7 +231,7 @@ void PackageBrowser::item_select(void *p, int s)
 
                        ept::debtags::Debtags debtags;
 
-                       set<ept::debtags::Tag> tags = 
debtags.getTagsOfItem("libc6");
+                       set<ept::debtags::Tag> tags = 
debtags.getTagsOfItem((const char *)data);
                        char *tag_txt = new char[512];
                        for (set<ept::debtags::Tag>::const_iterator i = 
tags.begin(); i != tags.end(); ++i)
                        {
diff --git a/gui_cli.cpp b/gui_cli.cpp
index d6c30f5..b0dd3da 100644
--- a/gui_cli.cpp
+++ b/gui_cli.cpp
@@ -36,6 +36,9 @@
 #include <iostream>
 #include <cmath>
 
+#include <limits.h>
+#include <sys/stat.h>
+
 #ifdef USE_GETTEXT
 #include <libintl.h>
 #include <locale.h>
@@ -58,14 +61,22 @@ static bool Go(PackageData &pkgdata)
 
        out << "# System running" << std::endl;
 
-       struct slre_pattern pattern[5];
-       const char *pattern_text[5];
-       const char pattern_type[] = { 'h', 'l', 'g', 's', '\0' };
-       pattern_text[0] = "^\\s*(HELP|H)\\s*$";
-       pattern_text[1] = 
"^\\s*(LIST|L)\\s+(T|TYPES|I|INTERFACES|R|RESULTS)\\s*$";
-       pattern_text[2] = "^\\s*(GET|G)\\s+(\\S+)\\s*$";
-       pattern_text[3] = "^\\s*(SET|S)\\s+(\\S+)\\s*=\\s*((\\S|\\s)*\\S)\\s*$";
-       pattern_text[4] = NULL;
+       struct slre_pattern pattern[16];
+       const char *pattern_text[16];
+       char pattern_type[16];
+       int i=0;
+       pattern_type[i]='H'; pattern_text[i++] = "^\\s*(HELP|H)\\s*$";
+       pattern_type[i]='T'; pattern_text[i++] = "^\\s*(TY|TYPES)\\s*$";
+       pattern_type[i]='I'; pattern_text[i++] = "^\\s*(I|INTERFACES)\\s*$";
+       pattern_type[i]='R'; pattern_text[i++] = "^\\s*(R|RESULTS)\\s*$";
+       pattern_type[i]='P'; pattern_text[i++] = 
"^\\s*(P|PACKAGE)\\s+(\\S+)\\s*$";
+       pattern_type[i]='S'; pattern_text[i++] = 
"^\\s*(S|SCREENSHOT)\\s+(\\S+)\\s*$";
+       pattern_type[i]='X'; pattern_text[i++] = 
"^\\s*(TA|TAGS)\\s+(\\S+)\\s*$";
+
+       pattern_type[i]='g'; pattern_text[i++] = "^\\s*(GET|G)\\s+(\\S+)\\s*$";
+       pattern_type[i]='s'; pattern_text[i++] = 
"^\\s*(SET|S)\\s+(\\S+)\\s*=\\s*((\\S|\\s)*\\S)\\s*$";
+
+       pattern_type[i]='\0'; pattern_text[i++] = NULL;
 
        int j = 0;
        while (pattern_text[j] != NULL)
@@ -90,11 +101,20 @@ static bool Go(PackageData &pkgdata)
                        }
                }
 
-               static const char *pattern_name[16] = { "Show help", "Show 
list", "Get parameter", "Set parameter", NULL};
+               static const char *pattern_name[16] = {
+                       "Show help",
+                       "List types",
+                       "List interfaces",
+                       "List results",
+                       "Show package",
+                       "Show screenshot",
+                       "Show tags",
+                       NULL
+               };
 
                int match = -1;
                int j = 0;
-               while (match == -1 && pattern_text[j] != NULL)
+               while (match == -1 && pattern_text[j] != NULL && 
pattern_name[j] != NULL)
                {
                        if (slre_match(pattern+j, buffer, strlen(buffer), 
captures))
                        {
@@ -103,91 +123,172 @@ static bool Go(PackageData &pkgdata)
                        }
                        j++;
                }
+
                if (match == -1)
                        out << "# Syntax Error: Command pattern not recognized" 
<< std::endl;
                else switch (pattern_type[match])
                {
-                       case 'h':
+                       case 'H':
                        {
                                out << "# Commands:" << std::endl
                                        << "# HELP" << std::endl
+                                       << "# TYPES" << std::endl
+                                       << "# INTERFACES" << std::endl
+                                       << "# RESULTS" << std::endl
                                        << "# LIST TYPES|INTERFACES|RESULTS" << 
std::endl
                                        << "# GET <param>" << std::endl
                                        << "# SET <param>=<value>" << std::endl;
                        }
                        break;
-                       case 'l':
+
+                       case 'T': case 't':
+                       {
+                               const PackageData::TagSet types = 
pkgdata.types();
+                               for (PackageData::TagSet::const_iterator i = 
types.begin(); i != types.end(); ++i)
+                               {
+                                       out << " " << i->fullname() << "\t" << 
i->shortDescription().c_str() << std::endl;
+                               }
+                               out << std::endl ;
+                       }
+                       break;
+
+                       case 'I': case 'i':
                        {
-                               out << "# List: \"" << captures[2].ptr <<  "\"" 
<< std::endl;
-                               switch (captures[2].ptr[0])
+                               const PackageData::TagSet ifaces = 
pkgdata.interfaces();
+                               for (PackageData::TagSet::const_iterator i = 
ifaces.begin();
+                                               i != ifaces.end(); ++i)
                                {
-                                       case 'T': case 't':
+                                       out << " " << i->fullname() << "\t" << 
i->shortDescription().c_str() << std::endl;
+                               }
+                               out << std::endl ;
+                       }
+                       break;
+
+                       case 'R': case 'r':
+                       {
+                               const std::vector<Result> res = 
pkgdata.results();
+                               for (vector<Result>::const_iterator i = 
res.begin();
+                                               i != res.end(); ++i)
+                               {
+                                       PackageRecord 
rec(pkgdata.apt().rawRecord(i->name));
+//                                     char* userData = 
pkgString(rec.package());
+                                               set<Tag> tags = 
pkgdata.debtags().getTagsOfItem((const char *)rec.package().c_str());
+                                       switch 
(pkgdata.GetPackageFilter().TagsValue(tags))
                                        {
-                                               const PackageData::TagSet types 
= pkgdata.types();
-                                               for 
(PackageData::TagSet::const_iterator i = types.begin(); i != types.end(); ++i)
-                                               {
-                                                       out << " " << 
i->fullname() << "\t" << i->shortDescription().c_str() << std::endl;
-                                               }
-                                               out << std::endl ;
-                                               break;
+                                               case PackageFilter::Green:
+                                                       break;
+                                               case PackageFilter::Yellow:
+                                                       break;
+                                               case PackageFilter::Red:
+                                                       break;
+                                               case PackageFilter::Black:
+                                                       break;
+                                               default:
+                                                       break;
                                        }
-                                       case 'I': case 'i':
+
+                                       out << " "<<  rec.package() + "\t" + 
rec.shortDescription();
+
+                                       // Relevance is 0 to 100
+                                       // Popcon is a weird floating point 
number (to be improved)
+                                       //FIXMEaddToResults(rec.package() + " - 
" + rec.shortDescription(), i->relevance, i->popcon);
+                                       if (pkgdata.popcon().hasData() && 
i->popcon)
                                        {
-                                               const PackageData::TagSet 
ifaces = pkgdata.interfaces();
-                                               for 
(PackageData::TagSet::const_iterator i = ifaces.begin();
-                                                               i != 
ifaces.end(); ++i)
-                                               {
-                                                       out << " " << 
i->fullname() << "\t" << i->shortDescription().c_str() << std::endl;
-                                               }
-                                               out << std::endl ;
-                                               break;
+                                               out << "\tPOPCON=" << 
(int)rintf(log(i->popcon) * 100 / log(pkgdata.popconLocalMax()));
                                        }
-                                       case 'R': case 'r':
+
+                                       if (pkgdata.popcon().hasData() && 
i->relevance)
                                        {
-                                               const std::vector<Result> res = 
pkgdata.results();
-                                               for 
(vector<Result>::const_iterator i = res.begin();
-                                                               i != res.end(); 
++i)
-                                               {
-                                                       PackageRecord 
rec(pkgdata.apt().rawRecord(i->name));
-//                                                     char* userData = 
pkgString(rec.package());
-                                                               set<Tag> tags = 
pkgdata.debtags().getTagsOfItem((const char *)rec.package().c_str());
-                                                       switch 
(pkgdata.GetPackageFilter().TagsValue(tags))
-                                                       {
-                                                               case 
PackageFilter::Green:
-                                                                       break;
-                                                               case 
PackageFilter::Yellow:
-                                                                       break;
-                                                               case 
PackageFilter::Red:
-                                                                       break;
-                                                               case 
PackageFilter::Black:
-                                                                       break;
-                                                               default:
-                                                                       break;
-                                                       }
-
-                                                       out << " "<<  
rec.package() + "\t" + rec.shortDescription();
-
-                                                       // Relevance is 0 to 100
-                                                       // Popcon is a weird 
floating point number (to be improved)
-                                                       
//FIXMEaddToResults(rec.package() + " - " + rec.shortDescription(), 
i->relevance, i->popcon);
-                                                       if 
(pkgdata.popcon().hasData() && i->popcon)
-                                                       {
-                                                               out << 
"\tPOPCON=" << (int)rintf(log(i->popcon) * 100 / log(pkgdata.popconLocalMax()));
-                                                       }
-
-                                                       if 
(pkgdata.popcon().hasData() && i->relevance)
-                                                       {
-                                                               out << 
"\tRELEVANCE=" << i->relevance;
-                                                       }
-
-                                                       out << std::endl ;
-                                               }
-                                               out << std::endl ;
-                                               break;
+                                               out << "\tRELEVANCE=" << 
i->relevance;
                                        }
+
+                                       out << std::endl ;
                                }
+
+                               out << std::endl ;
                        }
                        break;
+
+                       case 'P':
+                       {
+                               char name[sizeof(buffer)];
+                               strncpy(name, captures[2].ptr, captures[2].len);
+                               name[captures[2].len] = '\0';
+                               out << "# Package " << name << std::endl ;
+
+                               std::string pkg_desc;
+
+                               PackageRecord 
rec(pkgdata.apt().rawRecord(name));
+                               out << "NAME=" << rec.package() << std::endl ;
+                               out << "DESC=" << rec.shortDescription() << 
std::endl ;
+                               out << "LONG=" << rec.longDescription() << 
std::endl ;
+
+                               out << std::endl ;
+                       }
+                       break;
+
+                       case 'S':
+                       {
+                               char name[sizeof(buffer)];
+                               strncpy(name, captures[2].ptr, captures[2].len);
+                               name[captures[2].len] = '\0';
+                               out << "# Package " << name << std::endl ;
+
+                               char filename[PATH_MAX];
+                               struct stat fileinfo;
+
+                               if (snprintf(filename, PATH_MAX, "%s/%s.png", 
THUMBNAILSDIR, name) &&
+                                       stat(filename, &fileinfo) == 0)
+                               { // Portable Network Graphics (PNG) image files
+                                       // We were able to get the file 
attributes so the file obviously exists.
+                                       out << "PNG=" << filename << std::endl ;
+                               }
+                               else if (snprintf(filename, PATH_MAX, 
"%s/%s.jpg", THUMBNAILSDIR, name) &&
+                                       stat(filename, &fileinfo) == 0)
+                               { // Joint Photographic Experts Group (JPEG) 
File Interchange Format (JFIF) images.
+                                       out << "JPEG=" << filename << std::endl 
;
+                               }
+                               else if (snprintf(filename, PATH_MAX, 
"%s/%s.jpeg", THUMBNAILSDIR, name) &&
+                                       stat(filename, &fileinfo) == 0)
+                               {
+                                       out << "JPEG=" << filename << std::endl 
;
+                               }
+                               else if (snprintf(filename, PATH_MAX, 
"%s/%s.bmp", THUMBNAILSDIR, name) &&
+                                       stat(filename, &fileinfo) == 0)
+                               { // Windows Bitmap (BMP) image files
+                                       out << "BMP=" << filename << std::endl ;
+                               }
+                               else
+                               { // TODO: Portable Anymap (PNM, PBM, PGM, PPM) 
image files
+                                       out << "NULL" << std::endl ;
+                               }
+
+                               out << std::endl ;
+                       }
+                       break;
+
+                       case 'X':
+                       {
+                               char name[sizeof(buffer)];
+                               strncpy(name, captures[2].ptr, captures[2].len);
+                               name[captures[2].len] = '\0';
+                               out << "# Package " << name << std::endl ;
+
+                               ept::debtags::Debtags debtags;
+                               set<ept::debtags::Tag> tags = 
debtags.getTagsOfItem(name);
+                               for (set<ept::debtags::Tag>::const_iterator i = 
tags.begin(); i != tags.end(); ++i)
+                               {
+                                       out
+                                               << i->facet().name() << "::" << 
i->name() << " \""
+                                               << 
gettext(i->facet().shortDescription().c_str())
+                                               << "\"::\"" << 
gettext(i->shortDescription().c_str()) << "\""
+                                               << std::endl ;
+                               }
+
+                               out << std::endl ;
+                       }
+                       break;
+
                        case 'g':
                        {
                                char name[sizeof(buffer)];
@@ -230,6 +331,7 @@ static bool Go(PackageData &pkgdata)
                                }
                        }
                        break;
+
                        case 's':
                        {
                                char name[sizeof(buffer)];
@@ -279,6 +381,7 @@ static bool Go(PackageData &pkgdata)
 
                        }
                        break;
+
                        default:
                        break;
                }

-- 
Development fot GoFind!

_______________________________________________
Pkg-games-commits mailing list
[email protected]
http://lists.alioth.debian.org/mailman/listinfo/pkg-games-commits

Reply via email to