Argh, stupid forum, an stupid me!
I started to write a long message, with remarks on your code, but I was stupid to write it directly in the browser, without saving it.
Then I went to do something else and I accidentally clicked on the close button of the tab instead of activating it. That was my stupid mistakes.
Stupid forum because: 1) It is Ajax based; so when I restore the tab, Firefox cannot restore the content of the answer box, like it does usually, because there is no answer box in the restored tab! and 2) It doesn't save work in progress (like Sun's forum and some others do); so it does only half of the Ajax work 3) It doesn't even ask confirmation of tab closing (although admittedly it is hard to impossible to make it cross-browser).

Anyway, I will take a different approach, annotating/modifying your code, might be faster...

Overall, the code is good: it works as expected and looks nice. My remarks will be on coding style rather than functionality, so feel free to ignore them if you disagree (of course!).
I do lot of code maintenance, so my remarks go toward code readability and ease of maintenance, something most Processing coders don't care much (except when writing libraries, perhaps...).

Will post in a separate message...

1. PFont fontA;
2. // Wow, that's a long constructor!
3. // Since Java doesn't support named parameters,
   
4. // such super long call should be avoided, in favor of other style using setters.
5. // The risk here is to mix up parameters, forget some or invert them.
6. // At best the compiler will complain, at worst, you get some subtle runtime glitches...
7. TButton tb0 = new TButton("TButton v0.11",149,99,28,130,#888888,#004400,#889977,#880000,5,3,#667755,#550000);
8. // And you should add spaces after colons and around operators, this goes a long way toward readability!
9. TButton tb1 = new TButton("by Brian Wong",149,199,28,130,#778899,#000066,#887799,#dddd00,10,7,#665577,#aaaa00);
10. int bgc=0;
11. 
    
12. void setup(){
13.   size(300,300);
14.   smooth();
15.   // This is OK here, but annoying in a larger sketch, which might need different settings
16.   // Look at pushStyle()
17.   rectMode(CENTER);
18.   fontA = loadFont("Glockenspiel-16.vlw");
19.   textAlign(CENTER,CENTER);
20.   textFont(fontA,16);
21.   noStroke();
22. }
23. 
    
24. void draw(){
25.   background(bgc);
26.   // No need to set the variable to false...
27.   boolean buttonClicked0=false;
28.   // Since you immediately overwrite it!
29.   buttonClicked0=tb0.update(buttonClicked0);
30.   // You can use boolean variables directly, it looks more like English:
31.   // if (buttonClicked0) {
32.   if(buttonClicked0==true){
33.     if(bgc==0){
34.       bgc=255;
35.       tb0.pos(width/2,height*2/3);
36.       tb1.pos(width/2,height/3);
37.     } else {
38.       bgc=0;
39.       tb0.pos(width/2,height/3);
40.       tb1.pos(width/2,height*2/3);
41.     }
42.   }
43.   boolean buttonClicked1=false;
44.   buttonClicked1=tb1.update(buttonClicked1);
45.   if(buttonClicked1==true){
46.     if(bgc==#abcdef){
47.       bgc=0;
48.       tb0.pos(width/2,height*2/3);
49.       tb1.pos(width/2,height/3);
50.     } else {
51.       bgc=#abcdef;
52.       tb0.pos(width/2,height/3);
53.       tb1.pos(width/2,height*2/3);
54.     }
55.   }
56. }
57. 
    
58. class TButton{
59.   String buttonText;
60.   // This is often frowned upon: lot of people recommend to put one declaration per line.
61.   // This ease documentation of each field, and their initialization, and re-ordering if needed.
62.   int buttonWidth, buttonHeight;
63.   int buttonX,buttonY, bgCol,textCol,bgoCol,textoCol,bevSize,bevpSize,bgpCol,textpCol;
64.   // That's the default value, so the initialization is unnecessary.
65.   // Actually, it makes the field to be initialized twice: once at creation time,
66.   // and once at static initializalition time (before the constructor call). Quite annoying when debugging...
67.   // Default values are 0, false, null...
68.   boolean buttonPressed=false;
69.   boolean buttonClicked=false;
70.   TButton(String bt, int x, int y, int fh , int bw, int bgc, int textc, int oc, int toc, int bv, int bvp, int pc, int tpc){
71.     buttonText=bt;
72.     buttonX=x;
73.     buttonY=y;
74.     buttonHeight=fh;
75.     buttonWidth=bw;
76.     bgCol=bgc;
77.     bgoCol=oc;
78.     textCol=textc;
79.     bevSize=bv;
80.     textoCol=toc;
81.     bevpSize=bvp;
82.     bgpCol=pc;
83.     textpCol=tpc;
84.   }
85.   boolean update(boolean buttonClicked){
86.     // Don't be afraid of splitting long lines
87.     if((mouseX>buttonX-buttonWidth/2-bevSize)&&(mouseX<buttonX+buttonWidth/2+bevSize)&&(mouseY>buttonY-buttonHeight/2-bevSize)&&(mouseY<buttonY+buttonHeight/2+bevSize)){
88.       if((buttonPressed==false)&&(mousePressed==true)){
89.         buttonPressed=true;
90.       }
91.       // Same remark on booleans. And too many parentheses and not enough space: the eye is lost.
92.       if((buttonPressed==true)&&(mousePressed==false)){
93.         buttonPressed=false;
94.         buttonClicked=true;
95.       }
96.       if((buttonPressed==true)&&(mousePressed==true)){
97.         bevel(bgpCol,textpCol,bevpSize);
98.       } else {bevel(bgoCol,textoCol,bevSize);}
99.     } else {
100.       buttonPressed=false;
101.       bevel(bgCol,textCol,bevSize);
102.       }
103.     // You don't need parentheses there, return is a keyword, not a function call.
104.     return(buttonClicked);
105.     } // Beware of indentation!
106.   // This method is used only inside the class. You should make it private, so it won't be called from outside.
107.   // And by making the other methods public (even if not necessary in Processing), you make the official API clearer.
108.   void bevel(int bcol, int tcol, int bevSize){
109.     fill(bcol,255);
110.     rect(buttonX,buttonY,buttonWidth+bevSize*2,buttonHeight+bevSize*2);
111.     fill(tcol,255);
112.     text(buttonText,buttonX,buttonY);
113.     fill(bgCol);
114.     if(bevSize>0){
115.       fill(255,60);
116.       // You could use some intermediary variables...
117.       quad(buttonX-(buttonWidth/2)-bevSize, buttonY-buttonHeight/2-bevSize, buttonX+buttonWidth/2+bevSize, buttonY-buttonHeight/2-bevSize, buttonX+buttonWidth/2,buttonY-buttonHeight/2,buttonX-buttonWidth/2,buttonY-buttonHeight/2);
118.       fill(255,26);
119.       quad(buttonX+buttonWidth/2+bevSize, buttonY-buttonHeight/2-bevSize, buttonX+buttonWidth/2+bevSize, buttonY+buttonHeight/2+bevSize, buttonX+buttonWidth/2, buttonY+buttonHeight/2, buttonX+buttonWidth/2, buttonY-buttonHeight/2);
120.       fill(0,60);
121.       quad(buttonX+buttonWidth/2,buttonY+buttonHeight/2,buttonX+buttonWidth/2+bevSize,buttonY+buttonHeight/2+bevSize,buttonX-buttonWidth/2-bevSize,buttonY+buttonHeight/2+bevSize,buttonX-buttonWidth/2,buttonY+buttonHeight/2);
122.       fill(0,26);
123.       quad(buttonX-buttonWidth/2,buttonY+buttonHeight/2,buttonX-buttonWidth/2-bevSize,buttonY+buttonHeight/2+bevSize,buttonX-buttonWidth/2-bevSize,buttonY-buttonHeight/2-bevSize,buttonX-buttonWidth/2,buttonY-buttonHeight/2);
124.     }
125.   }
126.   void pos(int mx,int my){
127.     buttonX=mx;
128.     buttonY=my;
129.   }
130. }
131. 
     
132. void keyPressed() {
133.   if (key == ESC) {
134.     key = 0;
135.   }
136. }

Will show how I would rewrite this code in next message...

Partial rewrite, I will show how to improve the class later.

1. PFont fontA;
2. TButton tb0 = new TButton("TButton v0.11", 149, 99, 28, 130,
3.     #888888, #004400, #889977, #880000, 5, 3, #667755, #550000);
4. TButton tb1 = new TButton("by Brian Wong", 149, 199, 28, 130,
5.     #778899, #000066, #887799, #dddd00, 10, 7, #665577, #aaaa00);
6. int bgc = 0;
7. 
   
8. void setup() {
9.   size(300, 300);
10.   smooth();
11.   rectMode(CENTER);
12.   // Just to avoid creating the vlw file...
13.   fontA = createFont("Calibri", 16);
14.   textAlign(CENTER, CENTER);
15.   textFont(fontA, 16);
16.   noStroke();
17. }
18. 
    
19. void draw() {
20.   background(bgc);
21.   boolean buttonClicked0 = tb0.update(false);
22.   if (buttonClicked0) {
23.     if (bgc == 0) {
24.       bgc = 255;
25.       tb0.pos(width/2, height*2/3);
26.       tb1.pos(width/2, height/3);
27.     } else  {
28.       bgc = 0;
29.       tb0.pos(width/2, height/3);
30.       tb1.pos(width/2, height*2/3);
31.     }
32.   }
33. 
    
34.   boolean buttonClicked1 = tb1.update(false);
35.   if (buttonClicked1) {
36.     if (bgc == #abcdef) {
37.       bgc = 0;
38.       tb0.pos(width/2, height*2/3);
39.       tb1.pos(width/2, height/3);
40.     } else  {
41.       bgc = #abcdef;
42.       tb0.pos(width/2, height/3);
43.       tb1.pos(width/2, height*2/3);
44.     }
45.   }
46. }
47. 
    
48. class TButton {
49.   String buttonText;
50.   int buttonWidth, buttonHeight;
51.   int buttonX, buttonY, bgCol, textCol, bgoCol, textoCol, bevSize, bevpSize, bgpCol, textpCol;
52.   boolean buttonPressed;
53.   boolean buttonClicked;
54. 
    
55.   public TButton(String bt, int x, int y, int fh , int bw, int bgc, int textc, int oc, int toc,
56.       int bv, int bvp, int pc, int tpc) {
57.     buttonText = bt;
58.     buttonX = x;
59.     buttonY = y;
60.     buttonHeight = fh;
61.     buttonWidth = bw;
62.     bgCol = bgc;
63.     bgoCol = oc;
64.     textCol = textc;
65.     bevSize = bv;
66.     textoCol = toc;
67.     bevpSize = bvp;
68.     bgpCol = pc;
69.     textpCol = tpc;
70.   }
71. 
    
72.   public boolean update(boolean buttonClicked) {
73.     if (mouseX > buttonX - buttonWidth/2-bevSize &&
74.         mouseX < buttonX + buttonWidth/2 + bevSize &&
75.         mouseY > buttonY - buttonHeight/2-bevSize &&
76.         mouseY < buttonY + buttonHeight/2 + bevSize) {
77.       if (!buttonPressed && mousePressed) {
78.         buttonPressed = true;
79.       }
80.       if (buttonPressed && !mousePressed) {
81.         buttonPressed = false;
82.         buttonClicked = true;
83.       }
84.       if (buttonPressed && mousePressed) {
85.         bevel(bgpCol, textpCol, bevpSize);
86.       } else {
87.         bevel(bgoCol, textoCol, bevSize);
88.       }
89.     } else {
90.       buttonPressed = false;
91.       bevel(bgCol, textCol, bevSize);
92.     }
93.     return buttonClicked;
94.   }
95. 
    
96.   private void bevel(int bcol, int tcol, int bevSize) {
97.     fill(bcol, 255);
98.     rect(buttonX, buttonY, buttonWidth + bevSize * 2, buttonHeight + bevSize * 2);
99.     fill(tcol, 255);
100.     text(buttonText, buttonX, buttonY);
101.     fill(bgCol);
102.     if (bevSize > 0) {
103.       int hbh = buttonHeight / 2; // Half Button Height...
104.       int hbw = buttonWidth / 2; // Guess...
105.       fill(255, 60);
106.       quad(buttonX - hbw - bevSize, buttonY - hbh - bevSize,
107.           buttonX + hbw + bevSize, buttonY - hbh - bevSize,
108.           buttonX + hbw, buttonY - hbh,
109.           buttonX - hbw, buttonY - hbh);
110.       fill(255, 26);
111.       quad(buttonX + hbw + bevSize, buttonY - hbh - bevSize,
112.           buttonX + hbw + bevSize, buttonY + hbh + bevSize,
113.           buttonX + hbw, buttonY + hbh,
114.           buttonX + hbw, buttonY - hbh);
115.       fill(0, 60);
116.       quad(buttonX + hbw, buttonY + hbh,
117.           buttonX + hbw + bevSize, buttonY + hbh + bevSize,
118.           buttonX - hbw - bevSize, buttonY + hbh + bevSize,
119.           buttonX - hbw, buttonY + hbh);
120.       fill(0, 26);
121.       quad(buttonX - hbw, buttonY + hbh,
122.           buttonX - hbw - bevSize, buttonY + hbh + bevSize,
123.           buttonX - hbw - bevSize, buttonY - hbh - bevSize,
124.           buttonX - hbw, buttonY - hbh);
125.     }
126.   }
127. 
     
128.   public void pos(int mx, int my) {
129.     buttonX = mx;
130.     buttonY = my;
131.   }
132. }
133. 
     
134. void keyPressed() {
135.   if (key == ESC) {
136.     key = 0;
137.   }
138. }

I write these remarks in the hope some other people might find them useful...
Note: the buttonClicked field of TButton isn't used, it is shadowed by the buttonClicked parameter of update() and not used elsewhere. The buttonClicked parameter is actually useless... Can be made a local variable.

Wow, thanks so much for the detailed and well explained analysis! You have cleared up a number of issues I was wondering about while creating the code, and brought several new ideas to my attention. Your comments on coding style are very much appreciated and as a beginner I am hoping to adopt good coding habits.

Glad you find this useful!
Here is the last installment:

1. PFont fontA;
2. // Default button
3. TButton tbd;
4. TButton tb0;
5. TButton tb1;
6. color bgc = #000000;
7. 
   
8. void setup() {
9.   size(300, 400);
10.   smooth();
11.   // Just to avoid creating the vlw file...
12.   // Not perfect as the text font is global to the whole sketch.
13.   fontA = createFont("Calibri", 16);
14.   textFont(fontA, 16);
15. 
    
16.   tbd = new TButton("Default Button");
17.   tbd.setPosition(149, 300);
18. 
    
19.   tb0 = new TButton("TButton v0.11");
20.   tb0.setPosition(149, 99);
21.   tb0.setWidth(130).setHeight(28);
22.   // Default bevel size, don't change it
23.   tb0.setBackColor(#888888).setOverBackColor(#889977).setPressBackColor(#667755);
24.   tb0.setTextColor(#004400).setOverTextColor(#880000).setPressTextColor(#665577);
25. 
    
26.   tb1 = new TButton("by Brian Wong");
27.   tb1.setPosition(149, 199);
28.   tb1.setWidth(130).setHeight(28);
29.   tb1.setBevelSize(10).setPressBevelSize(7);
30.   tb1.setBackColor(#778899).setOverBackColor(#887799).setPressBackColor(#550000);
31.   tb1.setTextColor(#000066).setOverTextColor(#dddd00).setPressTextColor(#aaaa00);
32. }
33. 
    
34. boolean bDefaultActive;
35. void draw() {
36.   background(bgc);
37. 
    
38.   boolean buttonClicked0 = tb0.update();
39.   // Some people will prefer to  write if (tb0.update()) {
40.   // but having a separate variable makes easier to debug or print out its value,
41.   // and update() doesn't sound "natural" as a boolean value.
42.   if (buttonClicked0) {
43.     if (bgc == 0) {
44.       bgc = 255;
45.     } else  {
46.       bgc = 0;
47.     }
48.     swapButtons();
49.   }
50. 
    
51.   boolean buttonClicked1 = tb1.update();
52.   if (buttonClicked1) {
53.     if (bgc == #abcdef) {
54.       bgc = 0;
55.     } else  {
56.       bgc = #abcdef;
57.     }
58.     swapButtons();
59.   }
60. 
    
61.   boolean buttonClickedDefault = tbd.update();
62.   color c = #55FFAA;
63.   if (buttonClickedDefault) {
64.     bDefaultActive = !bDefaultActive; // Toggle it
65.   }
66.   if (bDefaultActive) {
67.     c = #FF55AA;
68.   }
69.   fill(c);
70.   // Note this ellipse has a stroke!
71.   ellipse(tbd.buttonX + tbd.buttonWidth, tbd.buttonY, tbd.buttonHeight, tbd.buttonHeight);
72. }
73. 
    
74. void swapButtons() {
75.   int px = tb0.buttonX;
76.   int py = tb0.buttonY;
77.   tb0.setPosition(tb1.buttonX, tb1.buttonY);
78.   tb1.setPosition(px, py);
79. }
80. 
    
81. class TButton {
82.   String buttonText;
83.   // Trying to set sensible default values, so that if setter isn't called, button still looks good
84.   int buttonWidth = 130;
85.   int buttonHeight = 30;
86.   int buttonX;
87.   int buttonY;
88.   // Avoid most abbreviations in identifier names: they don't save that much keystrokes,
89.   // even less with good text editors/IDEs. And they introduce confusion (col = color or column?)
90.   // and reduce readability.
91.   color bgColor = #C0C0C0; // BG is quite usual and not so much ambiguous
92.   color textColor = #000000;
93.   color bgOverColor = #D0D0E0;
94.   color textOverColor = #555555;
95.   int bevelSize = 5;
96.   int bevelPressSize = 3;
97.   color bgPressColor = #D0B0B0;
98.   color textPressColor = #775555;
99. 
    
100.   // Make it non accessible from outside
101.   private boolean buttonPressed;
102. 
     
103.   public TButton(String bt) {
104.     buttonText = bt;
105.   }
106. 
     
107.   // Define the setters.
108.   // The traditional way is to just make them void and just set the value in it,
109.   // but an useful extension is to make them return the object itself, allowing a nice chaining of calls.
110.   public TButton setHeight(int bh) {
111.     buttonHeight = bh;
112.     return this;
113.   }
114.   public TButton setWidth(int bw) {
115.     buttonWidth = bw;
116.     return this;
117.   }
118.   public TButton setBackColor(int bc) {
119.     bgColor = bc;
120.     return this;
121.   }
122.   public TButton setOverBackColor(int bc) {
123.     bgOverColor = bc;
124.     return this;
125.   }
126.   public TButton setPressBackColor(int bc) {
127.     bgPressColor = bc;
128.     return this;
129.   }
130.   public TButton setTextColor(int tc) {
131.     textColor = tc;
132.     return this;
133.   }
134.   public TButton setOverTextColor(int tc) {
135.     textOverColor = tc;
136.     return this;
137.   }
138.   public TButton setPressTextColor(int tc) {
139.     textPressColor = tc;
140.     return this;
141.   }
142.   public TButton setBevelSize(int bs) {
143.     bevelSize = bs;
144.     return this;
145.   }
146.   public TButton setPressBevelSize(int bs) {
147.     bevelPressSize = bs;
148.     return this;
149.   }
150. 
     
151.   public boolean update() {
152.     boolean buttonClicked = false;
153.     if (mouseX > buttonX - buttonWidth/2 - bevelSize &&
154.         mouseX < buttonX + buttonWidth/2 + bevelSize &&
155.         mouseY > buttonY - buttonHeight/2 - bevelSize &&
156.         mouseY < buttonY + buttonHeight/2 + bevelSize) {
157.       if (!buttonPressed && mousePressed) {
158.         buttonPressed = true;
159.       }
160.       if (buttonPressed && !mousePressed) {
161.         buttonPressed = false;
162.         buttonClicked = true;
163.       }
164.       if (buttonPressed && mousePressed) {
165.         bevel(bgPressColor, textPressColor, bevelPressSize);
166.       } else {
167.         bevel(bgOverColor, textOverColor, bevelSize);
168.       }
169.     } else {
170.       buttonPressed = false;
171.       bevel(bgColor, textColor, bevelSize);
172.     }
173.     return buttonClicked;
174.   }
175. 
     
176.   private void bevel(int bcol, int tcol, int bevelSize) {
177.     pushStyle();
178.     rectMode(CENTER);
179.     textAlign(CENTER, CENTER);
180.     noStroke();
181.     fill(bcol, 255);
182.     rect(buttonX, buttonY, buttonWidth + bevelSize * 2, buttonHeight + bevelSize * 2);
183.     fill(tcol, 255);
184.     text(buttonText, buttonX, buttonY);
185.     fill(bgColor);
186.     if (bevelSize > 0) {
187.       int hbh = buttonHeight / 2; // Half Button Height...
188.       int hbw = buttonWidth / 2; // Guess...
189.       int hbhB = hbh + bevelSize;
190.       int hbwB = hbw + bevelSize;
191.       fill(255, 60);
192.       quad(buttonX - hbwB, buttonY - hbhB,
193.           buttonX + hbwB, buttonY - hbhB,
194.           buttonX + hbw, buttonY - hbh,
195.           buttonX - hbw, buttonY - hbh);
196.       fill(255, 26);
197.       quad(buttonX + hbwB, buttonY - hbhB,
198.           buttonX + hbwB, buttonY + hbhB,
199.           buttonX + hbw, buttonY + hbh,
200.           buttonX + hbw, buttonY - hbh);
201.       fill(0, 60);
202.       quad(buttonX + hbw, buttonY + hbh,
203.           buttonX + hbwB, buttonY + hbhB,
204.           buttonX - hbwB, buttonY + hbhB,
205.           buttonX - hbw, buttonY + hbh);
206.       fill(0, 26);
207.       quad(buttonX - hbw, buttonY + hbh,
208.           buttonX - hbwB, buttonY + hbhB,
209.           buttonX - hbwB, buttonY - hbhB,
210.           buttonX - hbw, buttonY - hbh);
211.     }
212.     popStyle();
213.   }
214. 
     
215.   public void setPosition(int mx, int my) {
216.     buttonX = mx;
217.     buttonY = my;
218.   }
219. }
220. 
     
221. void keyPressed() {
222.   if (key == ESC) {
223.     key = 0;
224.   }
225. }

We can bring more improvements, but that's a good start, no?

That is great, this is really helping me finally get a grasp on OOP. The way you create the default button with the optional setters nicely demonstrates why my long constructor was bad style. Seeing that textFont is handled by pushStyle/popStyle I am guessing you are suggesting that it be moved there, but am uncertain on how it all should best be put together.

Yes, that's what I called "chaining of calls", but it is more called "fluid API", because it is easier to write (and read) that tb1.setXxx(); tb1.setYYY(); and so on.

The text font is annoying to manage (load) from the class, so the common scheme is to make the users to load it in setup(), and add another setter to set it on the class. Or, rather, it can be another parameter of the constructor, to make it mandatory call.

I have posted an updated version with setTextFont().

Added button transparency and an active background to demonstrate it. The plasma effect is from the sketch "Tiny Plasma" by Luis Gonzales.  http://bwong.ca/TButton_01.html

After testing with Linux/Firefox I noticed that the createFont was not working, so I changed the program over to loadFont. This also had the advantage of fixing the vertical centering problem for the fonts. I also added a setText() option.

Yes, I use createFont as a convenience to test code without creating a sketch folder, but I supposed you will revert back to loadFont...