Pango.H

Go to the documentation of this file.

/* Copyright 2000-2018 Matt Flax <flatmax@flatmax.org>
   This file is part of GTK+ IOStream class set

   GTK+ IOStream is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   GTK+ IOStream is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You have received a copy of the GNU General Public License
   along with GTK+ IOStream
*/
#ifndef PANGO_H_
#define PANGO_H_

#include "ColourLineSpec.H"
#include <sstream>

class Font : public string {
    PangoFontDescription *pangoFontDescription;

    void init(){pangoFontDescription=NULL;}
    public:
    Font() : string(){init();} 
    Font(const char *str) : string(str){init();} 
    Font(string str) : string(str){init();} 

    ~Font(void){
        if (pangoFontDescription)
            pango_font_description_free(pangoFontDescription);
        pangoFontDescription=NULL;
    }

    PangoFontDescription *getPangoFontDescription(void){
        if (pangoFontDescription)
            pango_font_description_free(pangoFontDescription);
        pangoFontDescription=NULL;
        return pangoFontDescription=pango_font_description_from_string(c_str());
    }
};

class PangoIOS {
    public:
    enum specialFlags {Next, Reset};

//    bool operator==(PangoIOS &pios, int psf){
//        return
//    }
};

class Pango {
    /*
    The internal workings of the class are such that each string is associated with a list of markup/variable pairs.
    In this manner, many markups may be applied to a single string.

    Thoughts for future expansion to handle <b> <i> and similar tags are to firstly add extra PangoIOS variables, such as PangoIOS::Bold, PangoIOS::Italic and so on.
    How to structure this is confounded by the following two concepts of which is dominant, a ColourLineSpec/Font tag OR a PangoIOS tag ? ...
    Pango pango;
    // want to carry the ColourLineSpec tag along, past the PangoIOS::Italic tag, suggesting that ColourLineSpec is superior.
    pango<<ColourLineSpec("r10000")<<"red 10 non italic"<<Pango::Italic<<"red 10 italic text";
    // want green to be italic as well which suggests that PangoIOS tags are superior
    pango<<Pango::Italic<<ColourLineSpec("r10000")<<"red 10 italic text"<<ColourLineSpec("g10000")<<"green 10 italic";
    */

    LinkList<LinkList<pair<string*, string*> *> *> markups; 
    LinkList<string*> strings; 

    enum pangoMarkupsIDs {COLOUR=1, SIZE, FONT}; 
    LinkList<string *> pangoMarkups; 

    string formattedMarkup; 

    void nextTag(void){
        markups.add(new LinkList<pair<string*, string*> *>); // add a new markups link
        strings.add(NULL); // add a new strings link
    }
public:

    Pango(void){
        pangoMarkups.add(new string("foreground")); // these must be in the same order of pangoMarkupsIDs
        pangoMarkups.add(new string("size"));
        pangoMarkups.add(new string("font"));
    }

    ~Pango(void){
        reset();
        while (pangoMarkups.getCount())
            delete pangoMarkups.remove();
    }

    string &getMarkup(void){
        formattedMarkup=""; // clear the markup string
        if (markups.getCount()){ // if markups and strings exist
            markups.grab(1); markups.prev(); // set both to the first element in their lists
            strings.grab(1); strings.prev();
            for (int i=1; i<=markups.getCount(); i++){ // cycle through each element
                markups.next(); strings.next();
                LinkList<pair<string*, string*> *> *currentMarkups= markups.current(); // get the list of markups strings and variables
                for (int j=1;j<=currentMarkups->getCount();j++){ // for each markup instruction, concat the markup and variable into formattedString
                    if (j==1) // if this is the last markup instruction, then complete the group of markups
                        formattedMarkup+="<span ";
                    currentMarkups->grab(j);
                    formattedMarkup+=(*currentMarkups->current()->first)+"='"+(*currentMarkups->current()->second)+"'";
                    if (j==currentMarkups->getCount()) // if this is the last markup instruction, then complete the group of markups
                        formattedMarkup+=">";
                    else // more to come, add a space
                        formattedMarkup+=" ";
                }
                // Now if the string is specified, add the string which is receiving the markup
                if (strings.current())
                    formattedMarkup+=(*strings.current());
                if (currentMarkups->getCount()) // finally, if a markup was specified, then end the markup session
                    formattedMarkup+="</span>";
            }
        }
        return formattedMarkup;
    }

    void setLabelText(GtkWidget *l){
        gtk_label_set_markup(GTK_LABEL(l), getMarkup().c_str());
    }

    Pango &operator<<(Font f){
        if (!strings.getCount() | (strings.current()!=NULL)) // we have completed the last string, start a new markup and string
            nextTag();
        markups.current()->add(new pair<string*, string*>(pangoMarkups.grab(FONT), new string(f))); // add the font markup and the associated font string
        return *this;
    }

    Pango &operator<<(ColourLineSpec cls){
        if (!strings.getCount() | (strings.current()!=NULL)) // we have completed the last string, start a new markup and string
            nextTag();
        if (cls.wasColourSpecified()){
            gchar *c=cls.getColourString();
            markups.current()->add(new pair<string*, string*>(pangoMarkups.grab(COLOUR), new string(c))); // add the size markup and the associated size string
            g_free(c);
        }
        if (cls.wasSizeSpecified()){
            ostringstream oss; oss<<cls.getSize(); // turn the size into a string
            markups.current()->add(new pair<string*, string*>(pangoMarkups.grab(SIZE), new string(oss.str()))); // add the size markup and the associated size string
        }
        return *this;
    }

    Pango &operator<<(string &s){
        if (!strings.getCount()) nextTag(); // incase there is no markup just text
        if (strings.current()==NULL)
            strings.change(new string(s));
        else
            (*strings.current())+=s;
        return *this;
    }

    Pango &operator<<(const char *s){
        string str(s);
        return operator<<(str);
    }

    Pango &operator<<(PangoIOS::specialFlags sf){
        if (sf==PangoIOS::Next) // handle a nextTag request
            nextTag();
        if (sf==PangoIOS::Reset) // handle a reset request
            reset();
        return *this;
    }

    void reset(void){
        // remove any previous strings and markups
        while (markups.getCount()){ // remove the markup pair linked lists and remove/delete each pair/string
            LinkList<pair<string*, string*> *> *llp=markups.remove();
            while (llp->getCount()){
                pair<string*, string*> *p=llp->remove();
                delete p->second;
                delete p;
            }
            delete llp;
        }
        while (strings.getCount()) // remove and delete the markup strings
            delete strings.remove();
    }
};
#endif // PANGO_H_