/** Replace font family leaving style alone (if possible). @param fontSpec the given font @param newFamily @return the changed fontspec, if the property can not be set return an empty string The routine first searches for an exact match. If no exact match found, calls FontSpecificationBestMatch(). */ Glib::ustring font_factory::ReplaceFontSpecificationFamily(const Glib::ustring & fontSpec, const Glib::ustring & newFamily) { Glib::ustring newFontSpec; // Although we are using the string from pango_font_description_to_string for the // font specification, we definitely cannot just set the new family in the // PangoFontDescription structure and ask for a new string. This is because // what constitutes a "family" in our own UI may be different from how Pango // sees it. // Find the PangoFontDescription associated with the old font specification string. PangoStringToDescrMap::iterator it = fontInstanceMap.find(fontSpec); if (it != fontInstanceMap.end()) { // Description found! // Make copy PangoFontDescription *descr = pango_font_description_copy((*it).second); // Grab the old UI Family string from the descr Glib::ustring uiFamily = GetUIFamilyString(descr); // Replace the UI Family name with the new family name std::size_t found = fontSpec.find(uiFamily); if (found != Glib::ustring::npos) { // Add comma to end of newFamily... commas at end don't hurt but are // required if the last part of a family name is a valid font style // (e.g. "Arial Black"). Glib::ustring newFamilyComma = newFamily; if( *newFamilyComma.rbegin() != ',' ) { newFamilyComma += ","; } newFontSpec = fontSpec; newFontSpec.erase(found, uiFamily.size()); newFontSpec.insert(found, newFamilyComma); // If the new font specification does not exist in the reference maps, // search for the next best match for the faces in that style it = fontInstanceMap.find(newFontSpec); if (it == fontInstanceMap.end()) { // Search for best match, empty string returned if not found. newFontSpec = FontSpecificationBestMatch( newFontSpec ); } } pango_font_description_free(descr); } return newFontSpec; }
/** * Save window position related details under provided path */ void jobManWindow::savePosition(const Glib::ustring &windowConfPath) { Gnome::Conf::init(); Glib::RefPtr<Gnome::Conf::Client> gConfClient(Gnome::Conf::Client::get_default_client()); gConfClient->add_dir(windowConfPath, Gnome::Conf::CLIENT_PRELOAD_ONELEVEL); Glib::ustring key; key.erase().append(windowConfPath).append("/size_height"); gConfClient->set(key, size_height); key.erase().append(windowConfPath).append("/size_width"); gConfClient->set(key, size_width); key.erase().append(windowConfPath).append("/pos_x"); gConfClient->set(key, pos_x); key.erase().append(windowConfPath).append("/pos_y"); gConfClient->set(key, pos_y); key.erase().append(windowConfPath).append("/isMaximized"); gConfClient->set(key, isMaximized); key.erase().append(windowConfPath).append("/panelSeparator"); gConfClient->set(key, paned.get_position()); }
/* compressed utf-8 table */ 0x20ac, /* 80 Euro. CP1252 from here on... */ 0x81, /* 81 NA */ 0x201a, /* 82 */ 0x192, /* 83 */ 0x201e, /* 84 */ 0x2026, /* 85 */ 0x2020, /* 86 */ 0x2021, /* 87 */ 0x2c6, /* 88 */ 0x2030, /* 89 */ 0x160, /* 8a */ 0x2039, /* 8b */ 0x152, /* 8c */ 0x8d, /* 8d NA */ 0x17d, /* 8e */ 0x8f, /* 8f NA */ 0x90, /* 90 NA */ 0x2018, /* 91 */ 0x2019, /* 92 */ 0x201c, /* 93 */ 0x201d, /* 94 */ 0x2022, /* 95 */ 0x2013, /* 96 */ 0x2014, /* 97 */ 0x2dc, /* 98 */ 0x2122, /* 99 */ 0x161, /* 9a */ 0x203a, /* 9b */ 0x153, /* 9c */ 0x9d, /* 9d NA */ 0x17e, /* 9e */ 0x178, /* 9f */ 0xa0, /* a0 */ 0xa1, /* a1 */ 0xa2, /* a2 */ 0xa3, /* a3 */ 0x20ac /* a4 ISO-8859-15 Euro. */ }; while (len) { if (G_UNLIKELY(*text >= 0x80) && G_UNLIKELY(*text <= 0xa4)) { int idx = *text - 0x80; output += lowtable[idx]; } else { output += (gunichar)*text; /* ascii/iso88591 maps directly */ } text++; len--; } return output; }/*}}}*/ void set_charset(Glib::ustring charset) {/*{{{*/ charset = charset.uppercase(); if (charset.find(' ') != Glib::ustring::npos) charset = charset.erase(charset.find(' ')); if (charset.empty() || !charset.compare("SYSTEM")) { charset.clear(); } else { try { Glib::IConv test("UTF-8", charset); } catch (...) { fprintf(stderr, "Charset '%s' isn't supported by your system - using system locale\n", charset.c_str()); charset.clear(); } } serverCharset = charset; }/*}}}*/
void ColorNotebook::_rgbaEntryChanged(GtkEntry* entry) { if (_updating) return; if (_updatingrgba) return; const gchar *t = gtk_entry_get_text( entry ); if (t) { Glib::ustring text = t; bool changed = false; if (!text.empty() && text[0] == '#') { changed = true; text.erase(0,1); if (text.size() == 6) { // it was a standard RGB hex unsigned int alph = SP_COLOR_F_TO_U(_alpha); gchar* tmp = g_strdup_printf("%02x", alph); text += tmp; g_free(tmp); } } gchar* str = g_strdup(text.c_str()); gchar* end = 0; guint64 rgba = g_ascii_strtoull( str, &end, 16 ); if ( end != str ) { ptrdiff_t len = end - str; if ( len < 8 ) { rgba = rgba << ( 4 * ( 8 - len ) ); } _updatingrgba = TRUE; if ( changed ) { gtk_entry_set_text( entry, str ); } SPColor color( rgba ); setColorAlpha( color, SP_RGBA32_A_F(rgba), true ); _updatingrgba = FALSE; } g_free(str); } }
bool FileManager::OpenFiles(int argc, char **argv) { #ifdef DEBUG std::cout << "OPENFILES: OpenFiles called \n"; #endif // DEBUG // makes sure we're dealing with a clean slate filenames.clear(); numfiles = 0; cwd_checked = false; initialised = false; /* // if we have initialised already we're being called from the file selector and will // accept new files now, let's set initialised and cwd_checked to 'false' and clear our file list if( initialised == true ) { numfiles = 0; cwd_checked = false; initialised = false; } // */ #ifdef DEBUG std::cout << "OPENFILES: get_current_dir_name(): " << get_current_dir_name() << std::endl; #endif // DEBUG if( argc > 1 ) { for(int i = 1; i < argc; i++) { if( stat(argv[i], &filemode) != 0 ) { std::cout << GT( "OPENFILES: Stat Error! Level 1 " ) << argv[i] << std::endl; } else { Glib::ustring filename; // Resolve any ".." and double / in the filename and make the filename absolute if( Glib::path_is_absolute( argv[i] ) ) filename = argv[i] ; else filename = (Glib::ustring)get_current_dir_name() + "/" + (Glib::ustring)argv[i]; while( filename.find("..") != Glib::ustring::npos ) { filename.erase( filename.rfind( '/', filename.find("..")-2), filename.find("..")+2 - filename.rfind( '/', filename.find("..")-2) ); } while( filename.find("//") != Glib::ustring::npos ) filename.erase( filename.find("//"), filename.find("//")+1 ); if( filename[ filename.length()-1 ] == '/' ) filename.erase( filename.length()-1, filename.length() ); if(filemode.st_mode & S_IFREG ) // if the file is a regular file { if( filter_filename(filename) ) // and seems to be a supported format { #ifdef DEBUG std::cout << "FILEMANAGER: curent argv: " << filename << std::endl; std::cout << "FILEMANAGER: dirname from argv: " << Glib::path_get_dirname( filename ) << std::endl; std::cout << "FILEMANAGER: curent dir: " << get_current_dir_name() << std::endl; #endif filenames.insert( filenames.end(), filename ); // insert into list numfiles++; } } else if(filemode.st_mode & S_IFDIR) // if the file is a directory { cwd_checked = true; if((currdir = opendir(filename.c_str())) != NULL) // open it { while( (dirinfo = readdir(currdir)) != NULL ) // run through it { // don't forget, we're doing some string to char* conversions here // here to avoid memory errors.. Glib::ustring is nice! Glib::ustring currfile(filename); // store the directory name currfile += '/'; // add a directory dash currfile += dirinfo->d_name; // add the filename if(stat(currfile.c_str(), &filemode) != 0) // check for filetype { std::cout << GT( "OPENFILES: Stat Error! Level 2 " ) << currfile << std::endl; } else { if( filemode.st_mode & S_IFREG && filter_filename(currfile) ) // as above { filenames.insert( filenames.end(), currfile ); // insert into list numfiles++; } } } closedir(currdir); } } } } filenames.sort(); file_iterator = filenames.begin(); } // when only one file was openened, we'll scan through its directory // and give the user control over the files if ( numfiles == 1 && cwd_checked == false ) { cwd_checked = true; Glib::ustring tempfilename = *file_iterator; // prepare the file's directory name in such a way that we can pass // it to OpenFiles() which operates on argc/argv char *dirname = new char[ (Glib::path_get_dirname( *file_iterator )).length() + 1 ]; strcpy( dirname, (Glib::path_get_dirname( *file_iterator )).c_str() ); char *arguments[] = { "empty" , dirname }; // we erase the list of filenames as otherwise we would have one file twice filenames.clear(); numfiles = 0; // now let's open the file's directory and check its contents OpenFiles( 2, arguments ); // now we have a new set of files in the list, we have to find the file that // the user actually wanted to open! std::list<Glib::ustring>::iterator end = filenames.end(); while( file_iterator != end ) { #ifdef DEBUG std::cout << "OPENFILES: Looking for " << tempfilename << " in " << (*file_iterator) << std::endl; #endif if( (*file_iterator).find( tempfilename ) != Glib::ustring::npos ) { break; // break out of the while loop if we find the filename } file_iterator++; } // when we have reached the end while looking, let's just load the first image! // as that means that either we didn't recognize the filename in our search above // or there was only one file in the directory after all! if( file_iterator == end ) file_iterator = filenames.begin(); #ifdef DEBUG std::cout << "OPENFILES: Deleting temporary dirname. \n"; #endif delete[] dirname; } // everything seems to have worked out alright, let's return true if ( numfiles > 0 ) { #ifdef DEBUG std::cout << "OPENFILES: We're all set to go and we have " << numfiles << " files." << std::endl; #endif // DEBUG return true; } // we did not have sufficient arguments or we have made some mistake, return false else { #ifdef DEBUG std::cout << "OPENFILES: We have " << numfiles << " files." << std::endl; #endif return false; } }